10699413358

Committed 04 Sep 2024 09:59AM UTC coverage: 46.191%. Remained the same

Build # 10699413358

Build Type

push

github

Committed by

hectorgomezv

Commit Message

Rebase changes

Run Details

499 of 3119 branches covered (16.0%)

Branch coverage included in aggregate %.

0 of 6 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

4837 of 8433 relevant lines covered (57.36%)

12.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

28.21

/src/domain/staking/staking.repository.ts

import {
  DedicatedStakingStats,
  DedicatedStakingStatsSchema,
} from '@/datasources/staking-api/entities/dedicated-staking-stats.entity';
import {
  DefiVaultStats,
  DefiVaultStatsSchema,
} from '@/datasources/staking-api/entities/defi-vault-stats.entity';
import {
  Deployment,
  DeploymentSchema,
} from '@/datasources/staking-api/entities/deployment.entity';
import {
  NetworkStats,
  NetworkStatsSchema,
} from '@/datasources/staking-api/entities/network-stats.entity';
import {
  PooledStakingStats,
  PooledStakingStatsSchema,
} from '@/datasources/staking-api/entities/pooled-staking-stats.entity';
import {
  Stake,
  StakeSchema,
} from '@/datasources/staking-api/entities/stake.entity';
import { IStakingApiManager } from '@/domain/interfaces/staking-api.manager.interface';
import { IStakingRepository } from '@/domain/staking/staking.repository.interface';
import { Inject, Injectable } from '@nestjs/common';

@Injectable()
export class StakingRepository implements IStakingRepository {
  constructor(
    @Inject(IStakingApiManager)
    private readonly stakingApiFactory: IStakingApiManager,
  ) {}

  public async getDeployment(args: {
    chainId: string;
    address: `0x${string}`;
  }): Promise<Deployment> {
    const deployments = await this.getDeployments(args.chainId);
    const deployment = deployments.find((deployment) => {
      return (
        args.chainId === deployment.chain_id.toString() &&
        args.address == deployment.address
      );
    });
    if (!deployment) {
      throw new Error('Deployment not found');
    }
    return deployment;
  }

  private async getDeployments(chainId: string): Promise<Array<Deployment>> {
    const stakingApi = await this.stakingApiFactory.getApi(chainId);
    const deployments = await stakingApi.getDeployments();
    return deployments.map((deployment) => DeploymentSchema.parse(deployment));
  }

  public async getNetworkStats(chainId: string): Promise<NetworkStats> {
    const stakingApi = await this.stakingApiFactory.getApi(chainId);
    const networkStats = await stakingApi.getNetworkStats();
    return NetworkStatsSchema.parse(networkStats);
  }

  public async getDedicatedStakingStats(
    chainId: string,
  ): Promise<DedicatedStakingStats> {
    const stakingApi = await this.stakingApiFactory.getApi(chainId);
    const dedicatedStakingStats = await stakingApi.getDedicatedStakingStats();
    return DedicatedStakingStatsSchema.parse(dedicatedStakingStats);
  }

  public async getPooledStakingStats(args: {
    chainId: string;
    pool: `0x${string}`;
  }): Promise<PooledStakingStats> {
    const stakingApi = await this.stakingApiFactory.getApi(args.chainId);
    const pooledStaking = await stakingApi.getPooledStakingStats(args.pool);
    return PooledStakingStatsSchema.parse(pooledStaking);
  }

  public async getDefiVaultStats(args: {
    chainId: string;
    vault: `0x${string}`;
  }): Promise<DefiVaultStats> {
    const stakingApi = await this.stakingApiFactory.getApi(args.chainId);
    const defiStats = await stakingApi.getDefiVaultStats(args);
    // Cannot be >1 contract deployed at the same address so return first element
    return defiStats.map((defiStats) =>
      DefiVaultStatsSchema.parse(defiStats),
    )[0];
  }

  public async getStakes(args: {
    chainId: string;
    validatorsPublicKeys: `0x${string}`[];
  }): Promise<Stake[]> {
    const stakingApi = await this.stakingApiFactory.getApi(args.chainId);
    const stakes = await stakingApi.getStakes(args.validatorsPublicKeys);
    return stakes.map((stake) => StakeSchema.parse(stake));
  }

  public clearApi(chainId: string): void {
    this.stakingApiFactory.destroyApi(chainId);
  }
}

1	import {	16✔
2	DedicatedStakingStats,
3	DedicatedStakingStatsSchema,
4	} from '@/datasources/staking-api/entities/dedicated-staking-stats.entity';
5	import {	16✔
6	DefiVaultStats,
7	DefiVaultStatsSchema,
8	} from '@/datasources/staking-api/entities/defi-vault-stats.entity';
9	import {	16✔
10	Deployment,
11	DeploymentSchema,
12	} from '@/datasources/staking-api/entities/deployment.entity';
13	import {	16✔
14	NetworkStats,
15	NetworkStatsSchema,
16	} from '@/datasources/staking-api/entities/network-stats.entity';
17	import {	16✔
18	PooledStakingStats,
19	PooledStakingStatsSchema,
20	} from '@/datasources/staking-api/entities/pooled-staking-stats.entity';
21	import {	16✔
22	Stake,
23	StakeSchema,
24	} from '@/datasources/staking-api/entities/stake.entity';
25	import { IStakingApiManager } from '@/domain/interfaces/staking-api.manager.interface';	16✔
26	import { IStakingRepository } from '@/domain/staking/staking.repository.interface';
27	import { Inject, Injectable } from '@nestjs/common';	16✔
28
29	@Injectable()
30	export class StakingRepository implements IStakingRepository {	16✔
31	constructor(
32	@Inject(IStakingApiManager)
33	private readonly stakingApiFactory: IStakingApiManager,	16✔
34	) {}
35
36	public async getDeployment(args: {
37	chainId: string;
38	address: `0x${string}`;
39	}): Promise<Deployment> {
UNCOV 40	const deployments = await this.getDeployments(args.chainId);	×
41	const deployment = deployments.find((deployment) => {	×
42	return (	×
43	args.chainId === deployment.chain_id.toString() &&	×
44	args.address == deployment.address
45	);
46	});
NEW 47	if (!deployment) {	×
NEW 48	throw new Error('Deployment not found');	×
49	}
NEW 50	return deployment;	×
51	}
52
53	private async getDeployments(chainId: string): Promise<Array<Deployment>> {
NEW 54	const stakingApi = await this.stakingApiFactory.getApi(chainId);	×
NEW 55	const deployments = await stakingApi.getDeployments();	×
NEW 56	return deployments.map((deployment) => DeploymentSchema.parse(deployment));	×
57	}
58
59	public async getNetworkStats(chainId: string): Promise<NetworkStats> {
60	const stakingApi = await this.stakingApiFactory.getApi(chainId);	×
61	const networkStats = await stakingApi.getNetworkStats();	×
62	return NetworkStatsSchema.parse(networkStats);	×
63	}
64
65	public async getDedicatedStakingStats(
66	chainId: string,
67	): Promise<DedicatedStakingStats> {
68	const stakingApi = await this.stakingApiFactory.getApi(chainId);	×
69	const dedicatedStakingStats = await stakingApi.getDedicatedStakingStats();	×
70	return DedicatedStakingStatsSchema.parse(dedicatedStakingStats);	×
71	}
72
73	public async getPooledStakingStats(args: {
74	chainId: string;
75	pool: `0x${string}`;
76	}): Promise<PooledStakingStats> {
77	const stakingApi = await this.stakingApiFactory.getApi(args.chainId);	×
78	const pooledStaking = await stakingApi.getPooledStakingStats(args.pool);	×
79	return PooledStakingStatsSchema.parse(pooledStaking);	×
80	}
81
82	public async getDefiVaultStats(args: {
83	chainId: string;
84	vault: `0x${string}`;
85	}): Promise<DefiVaultStats> {
86	const stakingApi = await this.stakingApiFactory.getApi(args.chainId);	×
87	const defiStats = await stakingApi.getDefiVaultStats(args);	×
88	// Cannot be >1 contract deployed at the same address so return first element
89	return defiStats.map((defiStats) =>	×
90	DefiVaultStatsSchema.parse(defiStats),	×
91	)[0];
92	}
93
94	public async getStakes(args: {
95	chainId: string;
96	validatorsPublicKeys: `0x${string}`[];
97	}): Promise<Stake[]> {
98	const stakingApi = await this.stakingApiFactory.getApi(args.chainId);	×
99	const stakes = await stakingApi.getStakes(args.validatorsPublicKeys);	×
100	return stakes.map((stake) => StakeSchema.parse(stake));	×
101	}
102
103	public clearApi(chainId: string): void {
104	this.stakingApiFactory.destroyApi(chainId);	2✔
105	}
106	}

safe-global / safe-client-gateway / 10699413358

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous