11515437952

Committed 25 Oct 2024 09:18AM UTC coverage: 88.944% (-1.3%) from 90.269%

Build # 11515437952

Build Type

Pull #2058

github

Committed by

web-flow

Commit Message

Merge 4c9c95e72 into 4fe315892

Pull Request Pull Request #2058: Remove FF_EVENTS_QUEUE

Run Details

2597 of 3278 branches covered (79.23%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 2 files covered. (100.0%)

87 existing lines in 12 files now uncovered.

8875 of 9620 relevant lines covered (92.26%)

398.37 hits per line

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

75.56

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

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

@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.vault);
    // 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;
    safeAddress: `0x${string}`;
    validatorsPublicKeys: Array<`0x${string}`>;
  }): Promise<Stake[]> {
    const stakingApi = await this.stakingApiFactory.getApi(args.chainId);
    const stakes = await stakingApi.getStakes(args);
    return stakes.map((stake) => StakeSchema.parse(stake));
  }

  public async clearStakes(args: {
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<void> {
    const stakingApi = await this.stakingApiFactory.getApi(args.chainId);
    await stakingApi.clearStakes(args.safeAddress);
  }

  public async getTransactionStatus(args: {
    chainId: string;
    txHash: `0x${string}`;
  }): Promise<TransactionStatus> {
    const stakingApi = await this.stakingApiFactory.getApi(args.chainId);
    const txStatus = await stakingApi.getTransactionStatus(args.txHash);
    return TransactionStatusSchema.parse(txStatus);
  }

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

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

safe-global / safe-client-gateway / 11515437952

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