10639751772

Committed 30 Aug 2024 10:09PM UTC coverage: 46.327% (-0.1%) from 46.432%

Build # 10639751772

Build Type

push

github

Committed by

web-flow

Commit Message

Add value/numValidators for ValidatorsExit transactions mappings (#1880)

Adds `value` and `numValidators` calculations based on the transaction data.

Run Details

499 of 3099 branches covered (16.1%)

Branch coverage included in aggregate %.

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

2 existing lines in 2 files now uncovered.

4811 of 8363 relevant lines covered (57.53%)

12.2 hits per line

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

13.04

/src/routes/transactions/mappers/common/native-staking.mapper.ts

import { NetworkStats } from '@/datasources/staking-api/entities/network-stats.entity';
import {
  ChainsRepositoryModule,
  IChainsRepository,
} from '@/domain/chains/chains.repository.interface';
import { Chain } from '@/domain/chains/entities/chain.entity';
import { getNumberString } from '@/domain/common/utils/utils';
import { DataDecoded } from '@/domain/data-decoder/entities/data-decoded.entity';
import { ModuleTransaction } from '@/domain/safe/entities/module-transaction.entity';
import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
import { IStakingRepository } from '@/domain/staking/staking.repository.interface';
import { StakingRepositoryModule } from '@/domain/staking/staking.repository.module';
import { NULL_ADDRESS } from '@/routes/common/constants';
import { NativeStakingDepositTransactionInfo } from '@/routes/transactions/entities/staking/native-staking-deposit-info.entity';
import { NativeStakingValidatorsExitTransactionInfo } from '@/routes/transactions/entities/staking/native-staking-validators-exit-info.entity';
import {
  StakingStatus,
  StakingValidatorsExitStatus,
} from '@/routes/transactions/entities/staking/staking.entity';
import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';
import { Inject, Injectable, Module, NotFoundException } from '@nestjs/common';

@Injectable()
export class NativeStakingMapper {
  private static readonly ETH_ETHERS_PER_VALIDATOR = 32;

  constructor(
    @Inject(IStakingRepository)
    private readonly stakingRepository: IStakingRepository,
    @Inject(IChainsRepository)
    private readonly chainsRepository: IChainsRepository,
  ) {}

  /**
   * Maps the {@link NativeStakingDepositTransactionInfo} for the given
   * native staking deployment's `deposit` call
   *
   * @param args.chainId - the chain ID of the native staking deployment
   * @param args.to - the address of the native staking deployment
   * @param args.value - the value of the deposit transaction
   * @param args.isConfirmed - whether the deposit transaction is confirmed
   * @param args.depositExecutionDate - the date when the deposit transaction was executed
   *
   * @returns {@link NativeStakingDepositTransactionInfo} for the given native staking deployment
   */
  public async mapDepositInfo(args: {
    chainId: string;
    to: `0x${string}`;
    value: string | null;
    isConfirmed: boolean;
    depositExecutionDate: Date | null;
  }): Promise<NativeStakingDepositTransactionInfo> {
    const chain = await this.chainsRepository.getChain(args.chainId);
    const deployment = await this.stakingRepository.getDeployment({
      chainId: args.chainId,
      address: args.to,
    });

    if (
      deployment.product_type !== 'dedicated' ||
      deployment.chain === 'unknown' ||
      deployment.status === 'unknown'
    ) {
      throw new NotFoundException('Native staking deployment not found');
    }

    const [nativeStakingStats, networkStats] = await Promise.all([
      this.stakingRepository.getDedicatedStakingStats(args.chainId),
      this.stakingRepository.getNetworkStats(args.chainId),
    ]);

    const value = args.value ? Number(args.value) : 0;
    const numValidators = Math.floor(
      value /
        Math.pow(10, chain.nativeCurrency.decimals) /
        NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR,
    );
    const fee = deployment.product_fee ? Number(deployment.product_fee) : 0;
    // NRR = GRR * (1 - service_fees)
    // Kiln also uses last_30d field, with product_fee
    const nrr = nativeStakingStats.gross_apy.last_30d * (1 - fee);
    const expectedAnnualReward = (nrr / 100) * value;
    const expectedMonthlyReward = expectedAnnualReward / 12;
    const expectedFiatAnnualReward =
      (expectedAnnualReward * (networkStats.eth_price_usd ?? 0)) /
      Math.pow(10, chain.nativeCurrency.decimals);
    const expectedFiatMonthlyReward = expectedFiatAnnualReward / 12;

    return new NativeStakingDepositTransactionInfo({
      status: this.mapDepositStatus(
        networkStats,
        args.isConfirmed,
        args.depositExecutionDate,
      ),
      estimatedEntryTime: networkStats.estimated_entry_time_seconds,
      estimatedExitTime: networkStats.estimated_exit_time_seconds,
      estimatedWithdrawalTime: networkStats.estimated_withdrawal_time_seconds,
      fee,
      monthlyNrr: nrr / 12,
      annualNrr: nrr,
      value: getNumberString(value),
      numValidators,
      expectedAnnualReward: getNumberString(expectedAnnualReward),
      expectedMonthlyReward: getNumberString(expectedMonthlyReward),
      expectedFiatAnnualReward,
      expectedFiatMonthlyReward,
      // tokenInfo is set to the native currency of the chain for native staking deposits
      tokenInfo: new TokenInfo({
        address: NULL_ADDRESS,
        decimals: chain.nativeCurrency.decimals,
        logoUri: chain.nativeCurrency.logoUri,
        name: chain.nativeCurrency.name,
        symbol: chain.nativeCurrency.symbol,
        trusted: true,
      }),
    });
  }

  // TODO: refactor common logic between mapDepositInfo and mapValidatorsExitInfo
  public async mapValidatorsExitInfo(args: {
    chainId: string;
    to: `0x${string}`;
    value: string | null;
    transaction: MultisigTransaction | ModuleTransaction | null;
  }): Promise<NativeStakingValidatorsExitTransactionInfo> {
    const chain = await this.chainsRepository.getChain(args.chainId);
    const deployment = await this.stakingRepository.getDeployment({
      chainId: args.chainId,
      address: args.to,
    });

    if (
      deployment.product_type !== 'dedicated' ||
      deployment.chain === 'unknown' ||
      deployment.status === 'unknown'
    ) {
      throw new NotFoundException('Native staking deployment not found');
    }

    const networkStats = await this.stakingRepository.getNetworkStats(
      args.chainId,
    );

    const value = args.transaction?.dataDecoded
      ? this.getValueFromDataDecoded(args.transaction.dataDecoded, chain)
      : Number(args.value ?? 0);

    const numValidators = Math.floor(
      value /
        Math.pow(10, chain.nativeCurrency.decimals) /
        NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR,
    );

    return new NativeStakingValidatorsExitTransactionInfo({
      status: this.mapValidatorsExitStatus(networkStats, args.transaction),
      estimatedExitTime: networkStats.estimated_exit_time_seconds,
      estimatedWithdrawalTime: networkStats.estimated_withdrawal_time_seconds,
      value: getNumberString(value),
      numValidators,
      tokenInfo: new TokenInfo({
        address: NULL_ADDRESS,
        decimals: chain.nativeCurrency.decimals,
        logoUri: chain.nativeCurrency.logoUri,
        name: chain.nativeCurrency.name,
        symbol: chain.nativeCurrency.symbol,
        trusted: true,
      }),
    });
  }

  /**
   * Maps the {@link StakingStatus} for the given native staking deployment's `deposit` call.
   * - If the deposit transaction is not confirmed, the status is `SignatureNeeded`.
   * - If the deposit transaction is confirmed but the deposit execution date is not available,
   * the status is `AwaitingExecution`.
   * - If the deposit execution date is available, the status is `AwaitingEntry` if the current
   * date is before the estimated entry time, otherwise the status is `ValidationStarted`.
   * - If the status cannot be determined, the status is `Unknown`.
   *
   * @param networkStats - the network stats for the chain where the native staking deployment lives
   * @param isConfirmed - whether the deposit transaction is confirmed
   * @param depositExecutionDate - the date when the deposit transaction was executed
   * @returns
   */
  private mapDepositStatus(
    networkStats: NetworkStats,
    isConfirmed: boolean,
    depositExecutionDate: Date | null,
  ): StakingStatus {
    if (!isConfirmed) {
      return StakingStatus.SignatureNeeded;
    }

    if (!depositExecutionDate) {
      return StakingStatus.AwaitingExecution;
    }

    const estimatedDepositEntryTime =
      depositExecutionDate.getTime() +
      networkStats.estimated_entry_time_seconds * 1000;

    return Date.now() <= estimatedDepositEntryTime
      ? StakingStatus.AwaitingEntry
      : StakingStatus.ValidationStarted;
  }

  private mapValidatorsExitStatus(
    networkStats: NetworkStats,
    transaction: MultisigTransaction | ModuleTransaction | null,
  ): StakingValidatorsExitStatus {
    const isConfirmed =
      transaction &&
      'confirmations' in transaction &&
      !!transaction.confirmations &&
      transaction.confirmations.length >= transaction.confirmationsRequired;

    if (!isConfirmed) {
      return StakingValidatorsExitStatus.SignatureNeeded;
    }

    if (!transaction.executionDate) {
      return StakingValidatorsExitStatus.AwaitingExecution;
    }

    // TODO: get validator status from the Kiln API
    const estimatedCompletionTime =
      transaction.executionDate.getTime() +
      networkStats.estimated_exit_time_seconds * 1000;

    return Date.now() <= estimatedCompletionTime
      ? StakingValidatorsExitStatus.RequestPending
      : StakingValidatorsExitStatus.ReadyToWithdraw;
  }

  private getValueFromDataDecoded(data: DataDecoded, chain: Chain): number {
    if (data.method === 'requestValidatorsExit') {
      const publicKeys =
        data.parameters?.filter(
          (parameter) => parameter.name === '_publicKeys',
        ) ?? [];
      const decimals = chain.nativeCurrency.decimals;
      return (
        publicKeys.length *
        Math.pow(10, decimals) *
        NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR
      );
    }

    return 0;
  }
}

@Module({
  imports: [StakingRepositoryModule, ChainsRepositoryModule],
  providers: [NativeStakingMapper],
  exports: [NativeStakingMapper],
})
export class NativeStakingMapperModule {}

1	import { NetworkStats } from '@/datasources/staking-api/entities/network-stats.entity';
2	import {	16✔
3	ChainsRepositoryModule,
4	IChainsRepository,
5	} from '@/domain/chains/chains.repository.interface';
6	import { Chain } from '@/domain/chains/entities/chain.entity';
7	import { getNumberString } from '@/domain/common/utils/utils';	16✔
8	import { DataDecoded } from '@/domain/data-decoder/entities/data-decoded.entity';
9	import { ModuleTransaction } from '@/domain/safe/entities/module-transaction.entity';
10	import { MultisigTransaction } from '@/domain/safe/entities/multisig-transaction.entity';
11	import { IStakingRepository } from '@/domain/staking/staking.repository.interface';	16✔
12	import { StakingRepositoryModule } from '@/domain/staking/staking.repository.module';	16✔
13	import { NULL_ADDRESS } from '@/routes/common/constants';	16✔
14	import { NativeStakingDepositTransactionInfo } from '@/routes/transactions/entities/staking/native-staking-deposit-info.entity';	16✔
15	import { NativeStakingValidatorsExitTransactionInfo } from '@/routes/transactions/entities/staking/native-staking-validators-exit-info.entity';	16✔
16	import {	16✔
17	StakingStatus,
18	StakingValidatorsExitStatus,
19	} from '@/routes/transactions/entities/staking/staking.entity';
20	import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';	16✔
21	import { Inject, Injectable, Module, NotFoundException } from '@nestjs/common';	16✔
22
23	@Injectable()
24	export class NativeStakingMapper {	16✔
25	private static readonly ETH_ETHERS_PER_VALIDATOR = 32;	16✔
26
27	constructor(
28	@Inject(IStakingRepository)
29	private readonly stakingRepository: IStakingRepository,	16✔
30	@Inject(IChainsRepository)
31	private readonly chainsRepository: IChainsRepository,	16✔
32	) {}
33
34	/**
35	* Maps the {@link NativeStakingDepositTransactionInfo} for the given
36	* native staking deployment's `deposit` call
37	*
38	* @param args.chainId - the chain ID of the native staking deployment
39	* @param args.to - the address of the native staking deployment
40	* @param args.value - the value of the deposit transaction
41	* @param args.isConfirmed - whether the deposit transaction is confirmed
42	* @param args.depositExecutionDate - the date when the deposit transaction was executed
43	*
44	* @returns {@link NativeStakingDepositTransactionInfo} for the given native staking deployment
45	*/
46	public async mapDepositInfo(args: {
47	chainId: string;
48	to: `0x${string}`;
49	value: string \| null;
50	isConfirmed: boolean;
51	depositExecutionDate: Date \| null;
52	}): Promise<NativeStakingDepositTransactionInfo> {
53	const chain = await this.chainsRepository.getChain(args.chainId);	×
54	const deployment = await this.stakingRepository.getDeployment({	×
55	chainId: args.chainId,
56	address: args.to,
57	});
58
59	if (	×
60	deployment.product_type !== 'dedicated' \|\|	×
61	deployment.chain === 'unknown' \|\|
62	deployment.status === 'unknown'
63	) {
64	throw new NotFoundException('Native staking deployment not found');	×
65	}
66
67	const [nativeStakingStats, networkStats] = await Promise.all([	×
68	this.stakingRepository.getDedicatedStakingStats(args.chainId),
69	this.stakingRepository.getNetworkStats(args.chainId),
70	]);
71
72	const value = args.value ? Number(args.value) : 0;	×
73	const numValidators = Math.floor(	×
74	value /
75	Math.pow(10, chain.nativeCurrency.decimals) /
76	NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR,
77	);
78	const fee = deployment.product_fee ? Number(deployment.product_fee) : 0;	×
79	// NRR = GRR * (1 - service_fees)
80	// Kiln also uses last_30d field, with product_fee
81	const nrr = nativeStakingStats.gross_apy.last_30d * (1 - fee);	×
82	const expectedAnnualReward = (nrr / 100) * value;	×
83	const expectedMonthlyReward = expectedAnnualReward / 12;	×
84	const expectedFiatAnnualReward =
85	(expectedAnnualReward * (networkStats.eth_price_usd ?? 0)) /	×
86	Math.pow(10, chain.nativeCurrency.decimals);
87	const expectedFiatMonthlyReward = expectedFiatAnnualReward / 12;	×
88
89	return new NativeStakingDepositTransactionInfo({	×
90	status: this.mapDepositStatus(
91	networkStats,
92	args.isConfirmed,
93	args.depositExecutionDate,
94	),
95	estimatedEntryTime: networkStats.estimated_entry_time_seconds,
96	estimatedExitTime: networkStats.estimated_exit_time_seconds,
97	estimatedWithdrawalTime: networkStats.estimated_withdrawal_time_seconds,
98	fee,
99	monthlyNrr: nrr / 12,
100	annualNrr: nrr,
101	value: getNumberString(value),
102	numValidators,
103	expectedAnnualReward: getNumberString(expectedAnnualReward),
104	expectedMonthlyReward: getNumberString(expectedMonthlyReward),
105	expectedFiatAnnualReward,
106	expectedFiatMonthlyReward,
107	// tokenInfo is set to the native currency of the chain for native staking deposits
108	tokenInfo: new TokenInfo({
109	address: NULL_ADDRESS,
110	decimals: chain.nativeCurrency.decimals,
111	logoUri: chain.nativeCurrency.logoUri,
112	name: chain.nativeCurrency.name,
113	symbol: chain.nativeCurrency.symbol,
114	trusted: true,
115	}),
116	});
117	}
118
119	// TODO: refactor common logic between mapDepositInfo and mapValidatorsExitInfo
120	public async mapValidatorsExitInfo(args: {
121	chainId: string;
122	to: `0x${string}`;
123	value: string \| null;
124	transaction: MultisigTransaction \| ModuleTransaction \| null;
125	}): Promise<NativeStakingValidatorsExitTransactionInfo> {
126	const chain = await this.chainsRepository.getChain(args.chainId);	×
127	const deployment = await this.stakingRepository.getDeployment({	×
128	chainId: args.chainId,
129	address: args.to,
130	});
131
132	if (	×
133	deployment.product_type !== 'dedicated' \|\|	×
134	deployment.chain === 'unknown' \|\|
135	deployment.status === 'unknown'
136	) {
137	throw new NotFoundException('Native staking deployment not found');	×
138	}
139
140	const networkStats = await this.stakingRepository.getNetworkStats(	×
141	args.chainId,
142	);
143
NEW 144	const value = args.transaction?.dataDecoded	×
145	? this.getValueFromDataDecoded(args.transaction.dataDecoded, chain)
146	: Number(args.value ?? 0);	×
147
UNCOV 148	const numValidators = Math.floor(	×
149	value /
150	Math.pow(10, chain.nativeCurrency.decimals) /
151	NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR,
152	);
153
154	return new NativeStakingValidatorsExitTransactionInfo({	×
155	status: this.mapValidatorsExitStatus(networkStats, args.transaction),
156	estimatedExitTime: networkStats.estimated_exit_time_seconds,
157	estimatedWithdrawalTime: networkStats.estimated_withdrawal_time_seconds,
158	value: getNumberString(value),
159	numValidators,
160	tokenInfo: new TokenInfo({
161	address: NULL_ADDRESS,
162	decimals: chain.nativeCurrency.decimals,
163	logoUri: chain.nativeCurrency.logoUri,
164	name: chain.nativeCurrency.name,
165	symbol: chain.nativeCurrency.symbol,
166	trusted: true,
167	}),
168	});
169	}
170
171	/**
172	* Maps the {@link StakingStatus} for the given native staking deployment's `deposit` call.
173	* - If the deposit transaction is not confirmed, the status is `SignatureNeeded`.
174	* - If the deposit transaction is confirmed but the deposit execution date is not available,
175	* the status is `AwaitingExecution`.
176	* - If the deposit execution date is available, the status is `AwaitingEntry` if the current
177	* date is before the estimated entry time, otherwise the status is `ValidationStarted`.
178	* - If the status cannot be determined, the status is `Unknown`.
179	*
180	* @param networkStats - the network stats for the chain where the native staking deployment lives
181	* @param isConfirmed - whether the deposit transaction is confirmed
182	* @param depositExecutionDate - the date when the deposit transaction was executed
183	* @returns
184	*/
185	private mapDepositStatus(
186	networkStats: NetworkStats,
187	isConfirmed: boolean,
188	depositExecutionDate: Date \| null,
189	): StakingStatus {
190	if (!isConfirmed) {	×
191	return StakingStatus.SignatureNeeded;	×
192	}
193
194	if (!depositExecutionDate) {	×
195	return StakingStatus.AwaitingExecution;	×
196	}
197
198	const estimatedDepositEntryTime =
199	depositExecutionDate.getTime() +	×
200	networkStats.estimated_entry_time_seconds * 1000;
201
202	return Date.now() <= estimatedDepositEntryTime	×
203	? StakingStatus.AwaitingEntry
204	: StakingStatus.ValidationStarted;
205	}
206
207	private mapValidatorsExitStatus(
208	networkStats: NetworkStats,
209	transaction: MultisigTransaction \| ModuleTransaction \| null,
210	): StakingValidatorsExitStatus {
211	const isConfirmed =
NEW 212	transaction &&	×
213	'confirmations' in transaction &&
214	!!transaction.confirmations &&
215	transaction.confirmations.length >= transaction.confirmationsRequired;
216
217	if (!isConfirmed) {	×
218	return StakingValidatorsExitStatus.SignatureNeeded;	×
219	}
220
NEW 221	if (!transaction.executionDate) {	×
222	return StakingValidatorsExitStatus.AwaitingExecution;	×
223	}
224
225	// TODO: get validator status from the Kiln API
226	const estimatedCompletionTime =
NEW 227	transaction.executionDate.getTime() +	×
228	networkStats.estimated_exit_time_seconds * 1000;
229
230	return Date.now() <= estimatedCompletionTime	×
231	? StakingValidatorsExitStatus.RequestPending
232	: StakingValidatorsExitStatus.ReadyToWithdraw;
233	}
234
235	private getValueFromDataDecoded(data: DataDecoded, chain: Chain): number {
NEW 236	if (data.method === 'requestValidatorsExit') {	×
237	const publicKeys =
NEW 238	data.parameters?.filter(	×
NEW 239	(parameter) => parameter.name === '_publicKeys',	×
240	) ?? [];
NEW 241	const decimals = chain.nativeCurrency.decimals;	×
NEW 242	return (	×
243	publicKeys.length *
244	Math.pow(10, decimals) *
245	NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR
246	);
247	}
248
NEW 249	return 0;	×
250	}
251	}
252
253	@Module({
254	imports: [StakingRepositoryModule, ChainsRepositoryModule],
255	providers: [NativeStakingMapper],
256	exports: [NativeStakingMapper],
257	})
258	export class NativeStakingMapperModule {}	16✔

safe-global / safe-client-gateway / 10639751772

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