10685102512

Committed 03 Sep 2024 02:34PM UTC coverage: 46.027% (+0.04%) from 45.988%

Build # 10685102512

Build Type

Pull #1893

github

Committed by

hectorgomezv

Commit Message

Merge branch 'main' into add-staking-transaction-info-tests

Pull Request Pull Request #1893: Add staking transaction info tests

Run Details

501 of 3160 branches covered (15.85%)

Branch coverage included in aggregate %.

5 of 11 new or added lines in 3 files covered. (45.45%)

1 existing line in 1 file now uncovered.

4839 of 8442 relevant lines covered (57.32%)

12.16 hits per line

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

10.39

/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 { NativeStakingWithdrawTransactionInfo } from '@/routes/transactions/entities/staking/native-staking-withdraw-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, deployment] = await Promise.all([
      this.chainsRepository.getChain(args.chainId),
      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,
      }),
    });
  }

  /**
   * Maps the {@link NativeStakingValidatorsExitTransactionInfo} for the given
   * native staking deployment's `validators exit` 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 validators exit transaction
   * @param args.transaction - the transaction object for the validators exit
   * @returns {@link NativeStakingValidatorsExitTransactionInfo} for the given native staking deployment
   */
  // TODO: refactor common logic between mapDepositInfo and mapValidatorsExitInfo and mapWithdrawInfo
  public async mapValidatorsExitInfo(args: {
    chainId: string;
    to: `0x${string}`;
    value: string | null;
    transaction: MultisigTransaction | ModuleTransaction | null;
  }): Promise<NativeStakingValidatorsExitTransactionInfo> {
    const [chain, deployment] = await Promise.all([
      this.chainsRepository.getChain(args.chainId),
      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 NativeStakingWithdrawTransactionInfo} for the given
   * native staking deployment's `withdraw` 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 withdraw transaction
   * @param args.transaction - the transaction object for the withdraw
   * @returns {@link NativeStakingWithdrawTransactionInfo} for the given native staking deployment
   */
  // TODO: refactor common logic between mapDepositInfo and mapValidatorsExitInfo and mapWithdrawInfo
  public async mapWithdrawInfo(args: {
    chainId: string;
    to: `0x${string}`;
    value: string | null;
    transaction: MultisigTransaction | ModuleTransaction | null;
  }): Promise<NativeStakingWithdrawTransactionInfo> {
    const [chain, deployment] = await Promise.all([
      this.chainsRepository.getChain(args.chainId),
      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');
    }

    let value = Number(args.value ?? 0);

    if (args.transaction) {
      const validatorsPublicKeys = args.transaction?.dataDecoded
        ? this.getPublicKeysFromDataDecoded(args.transaction.dataDecoded)
        : [];

      const stakes = await this.stakingRepository.getStakes({
        chainId: args.chainId,
        validatorsPublicKeys,
      });
      value = stakes.reduce((acc, stake) => acc + Number(stake.rewards), 0);
    }

    return new NativeStakingWithdrawTransactionInfo({
      value: getNumberString(value),
      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;
  }
  /**
   * Gets the total value to withdraw from the native staking deployment
   * based on the amount of publicKey items in the transaction data.
   *
   * Each publicKey item represents a validator to withdraw, and each
   * native staking validator has a fixed amount of 32 ETH to withdraw.
   *
   * @param data - the decoded data of the transaction
   * @param chain - the chain where the native staking deployment lives
   * @returns the total value to withdraw from the native staking deployment
   */
  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;
  }

  private getPublicKeysFromDataDecoded(data: DataDecoded): `0x${string}`[] {
    const publicKeys =
      data.parameters?.filter(
        (parameter) => parameter.name === '_publicKeys',
      ) ?? [];
    return publicKeys.map((publicKey) => publicKey.value as `0x${string}`);
  }
}

@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 { NativeStakingWithdrawTransactionInfo } from '@/routes/transactions/entities/staking/native-staking-withdraw-info.entity';	16✔
17	import {	16✔
18	StakingStatus,
19	StakingValidatorsExitStatus,
20	} from '@/routes/transactions/entities/staking/staking.entity';
21	import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';	16✔
22	import { Inject, Injectable, Module, NotFoundException } from '@nestjs/common';	16✔
23
24	@Injectable()
25	export class NativeStakingMapper {	16✔
26	private static readonly ETH_ETHERS_PER_VALIDATOR = 32;	16✔
27
28	constructor(
29	@Inject(IStakingRepository)
30	private readonly stakingRepository: IStakingRepository,	16✔
31	@Inject(IChainsRepository)
32	private readonly chainsRepository: IChainsRepository,	16✔
33	) {}
34
35	/**
36	* Maps the {@link NativeStakingDepositTransactionInfo} for the given
37	* native staking deployment's `deposit` call
38	*
39	* @param args.chainId - the chain ID of the native staking deployment
40	* @param args.to - the address of the native staking deployment
41	* @param args.value - the value of the deposit transaction
42	* @param args.isConfirmed - whether the deposit transaction is confirmed
43	* @param args.depositExecutionDate - the date when the deposit transaction was executed
44	*
45	* @returns {@link NativeStakingDepositTransactionInfo} for the given native staking deployment
46	*/
47	public async mapDepositInfo(args: {
48	chainId: string;
49	to: `0x${string}`;
50	value: string \| null;
51	isConfirmed: boolean;
52	depositExecutionDate: Date \| null;
53	}): Promise<NativeStakingDepositTransactionInfo> {
NEW 54	const [chain, deployment] = await Promise.all([	×
55	this.chainsRepository.getChain(args.chainId),
56	this.stakingRepository.getDeployment({
57	chainId: args.chainId,
58	address: args.to,
59	}),
60	]);
61
62	if (	×
63	deployment.product_type !== 'dedicated' \|\|	×
64	deployment.chain === 'unknown' \|\|
65	deployment.status === 'unknown'
66	) {
67	throw new NotFoundException('Native staking deployment not found');	×
68	}
69
70	const [nativeStakingStats, networkStats] = await Promise.all([	×
71	this.stakingRepository.getDedicatedStakingStats(args.chainId),
72	this.stakingRepository.getNetworkStats(args.chainId),
73	]);
74
75	const value = args.value ? Number(args.value) : 0;	×
76	const numValidators = Math.floor(	×
77	value /
78	Math.pow(10, chain.nativeCurrency.decimals) /
79	NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR,
80	);
81	const fee = deployment.product_fee ? Number(deployment.product_fee) : 0;	×
82	// NRR = GRR * (1 - service_fees)
83	// Kiln also uses last_30d field, with product_fee
84	const nrr = nativeStakingStats.gross_apy.last_30d * (1 - fee);	×
85	const expectedAnnualReward = (nrr / 100) * value;	×
86	const expectedMonthlyReward = expectedAnnualReward / 12;	×
87	const expectedFiatAnnualReward =
88	(expectedAnnualReward * (networkStats.eth_price_usd ?? 0)) /	×
89	Math.pow(10, chain.nativeCurrency.decimals);
90	const expectedFiatMonthlyReward = expectedFiatAnnualReward / 12;	×
91
92	return new NativeStakingDepositTransactionInfo({	×
93	status: this.mapDepositStatus(
94	networkStats,
95	args.isConfirmed,
96	args.depositExecutionDate,
97	),
98	estimatedEntryTime: networkStats.estimated_entry_time_seconds,
99	estimatedExitTime: networkStats.estimated_exit_time_seconds,
100	estimatedWithdrawalTime: networkStats.estimated_withdrawal_time_seconds,
101	fee,
102	monthlyNrr: nrr / 12,
103	annualNrr: nrr,
104	value: getNumberString(value),
105	numValidators,
106	expectedAnnualReward: getNumberString(expectedAnnualReward),
107	expectedMonthlyReward: getNumberString(expectedMonthlyReward),
108	expectedFiatAnnualReward,
109	expectedFiatMonthlyReward,
110	// tokenInfo is set to the native currency of the chain for native staking deposits
111	tokenInfo: new TokenInfo({
112	address: NULL_ADDRESS,
113	decimals: chain.nativeCurrency.decimals,
114	logoUri: chain.nativeCurrency.logoUri,
115	name: chain.nativeCurrency.name,
116	symbol: chain.nativeCurrency.symbol,
117	trusted: true,
118	}),
119	});
120	}
121
122	/**
123	* Maps the {@link NativeStakingValidatorsExitTransactionInfo} for the given
124	* native staking deployment's `validators exit` call
125	*
126	* @param args.chainId - the chain ID of the native staking deployment
127	* @param args.to - the address of the native staking deployment
128	* @param args.value - the value of the validators exit transaction
129	* @param args.transaction - the transaction object for the validators exit
130	* @returns {@link NativeStakingValidatorsExitTransactionInfo} for the given native staking deployment
131	*/
132	// TODO: refactor common logic between mapDepositInfo and mapValidatorsExitInfo and mapWithdrawInfo
133	public async mapValidatorsExitInfo(args: {
134	chainId: string;
135	to: `0x${string}`;
136	value: string \| null;
137	transaction: MultisigTransaction \| ModuleTransaction \| null;
138	}): Promise<NativeStakingValidatorsExitTransactionInfo> {
NEW 139	const [chain, deployment] = await Promise.all([	×
140	this.chainsRepository.getChain(args.chainId),
141	this.stakingRepository.getDeployment({
142	chainId: args.chainId,
143	address: args.to,
144	}),
145	]);
146
147	if (	×
148	deployment.product_type !== 'dedicated' \|\|	×
149	deployment.chain === 'unknown' \|\|
150	deployment.status === 'unknown'
151	) {
152	throw new NotFoundException('Native staking deployment not found');	×
153	}
154
155	const networkStats = await this.stakingRepository.getNetworkStats(	×
156	args.chainId,
157	);
158
159	const value = args.transaction?.dataDecoded	×
160	? this.getValueFromDataDecoded(args.transaction.dataDecoded, chain)
161	: Number(args.value ?? 0);	×
162
163	const numValidators = Math.floor(	×
164	value /
165	Math.pow(10, chain.nativeCurrency.decimals) /
166	NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR,
167	);
168
169	return new NativeStakingValidatorsExitTransactionInfo({	×
170	status: this.mapValidatorsExitStatus(networkStats, args.transaction),
171	estimatedExitTime: networkStats.estimated_exit_time_seconds,
172	estimatedWithdrawalTime: networkStats.estimated_withdrawal_time_seconds,
173	value: getNumberString(value),
174	numValidators,
175	tokenInfo: new TokenInfo({
176	address: NULL_ADDRESS,
177	decimals: chain.nativeCurrency.decimals,
178	logoUri: chain.nativeCurrency.logoUri,
179	name: chain.nativeCurrency.name,
180	symbol: chain.nativeCurrency.symbol,
181	trusted: true,
182	}),
183	});
184	}
185
186	/**
187	* Maps the {@link NativeStakingWithdrawTransactionInfo} for the given
188	* native staking deployment's `withdraw` call
189	*
190	* @param args.chainId - the chain ID of the native staking deployment
191	* @param args.to - the address of the native staking deployment
192	* @param args.value - the value of the withdraw transaction
193	* @param args.transaction - the transaction object for the withdraw
194	* @returns {@link NativeStakingWithdrawTransactionInfo} for the given native staking deployment
195	*/
196	// TODO: refactor common logic between mapDepositInfo and mapValidatorsExitInfo and mapWithdrawInfo
197	public async mapWithdrawInfo(args: {
198	chainId: string;
199	to: `0x${string}`;
200	value: string \| null;
201	transaction: MultisigTransaction \| ModuleTransaction \| null;
202	}): Promise<NativeStakingWithdrawTransactionInfo> {
203	const [chain, deployment] = await Promise.all([	×
204	this.chainsRepository.getChain(args.chainId),
205	this.stakingRepository.getDeployment({
206	chainId: args.chainId,
207	address: args.to,
208	}),
209	]);
210
211	if (	×
212	deployment.product_type !== 'dedicated' \|\|	×
213	deployment.chain === 'unknown' \|\|
214	deployment.status === 'unknown'
215	) {
216	throw new NotFoundException('Native staking deployment not found');	×
217	}
218
219	let value = Number(args.value ?? 0);	×
220
221	if (args.transaction) {	×
222	const validatorsPublicKeys = args.transaction?.dataDecoded	×
223	? this.getPublicKeysFromDataDecoded(args.transaction.dataDecoded)
224	: [];
225
226	const stakes = await this.stakingRepository.getStakes({	×
227	chainId: args.chainId,
228	validatorsPublicKeys,
229	});
230	value = stakes.reduce((acc, stake) => acc + Number(stake.rewards), 0);	×
231	}
232
233	return new NativeStakingWithdrawTransactionInfo({	×
234	value: getNumberString(value),
235	tokenInfo: new TokenInfo({
236	address: NULL_ADDRESS,
237	decimals: chain.nativeCurrency.decimals,
238	logoUri: chain.nativeCurrency.logoUri,
239	name: chain.nativeCurrency.name,
240	symbol: chain.nativeCurrency.symbol,
241	trusted: true,
242	}),
243	});
244	}
245
246	/**
247	* Maps the {@link StakingStatus} for the given native staking deployment's `deposit` call.
248	* - If the deposit transaction is not confirmed, the status is `SignatureNeeded`.
249	* - If the deposit transaction is confirmed but the deposit execution date is not available,
250	* the status is `AwaitingExecution`.
251	* - If the deposit execution date is available, the status is `AwaitingEntry` if the current
252	* date is before the estimated entry time, otherwise the status is `ValidationStarted`.
253	* - If the status cannot be determined, the status is `Unknown`.
254	*
255	* @param networkStats - the network stats for the chain where the native staking deployment lives
256	* @param isConfirmed - whether the deposit transaction is confirmed
257	* @param depositExecutionDate - the date when the deposit transaction was executed
258	* @returns
259	*/
260	private mapDepositStatus(
261	networkStats: NetworkStats,
262	isConfirmed: boolean,
263	depositExecutionDate: Date \| null,
264	): StakingStatus {
265	if (!isConfirmed) {	×
266	return StakingStatus.SignatureNeeded;	×
267	}
268
269	if (!depositExecutionDate) {	×
270	return StakingStatus.AwaitingExecution;	×
271	}
272
273	const estimatedDepositEntryTime =
274	depositExecutionDate.getTime() +	×
275	networkStats.estimated_entry_time_seconds * 1000;
276
277	return Date.now() <= estimatedDepositEntryTime	×
278	? StakingStatus.AwaitingEntry
279	: StakingStatus.ValidationStarted;
280	}
281
282	private mapValidatorsExitStatus(
283	networkStats: NetworkStats,
284	transaction: MultisigTransaction \| ModuleTransaction \| null,
285	): StakingValidatorsExitStatus {
286	const isConfirmed =
287	transaction &&	×
288	'confirmations' in transaction &&
289	!!transaction.confirmations &&
290	transaction.confirmations.length >= transaction.confirmationsRequired;
291
292	if (!isConfirmed) {	×
293	return StakingValidatorsExitStatus.SignatureNeeded;	×
294	}
295
296	if (!transaction.executionDate) {	×
297	return StakingValidatorsExitStatus.AwaitingExecution;	×
298	}
299
300	// TODO: get validator status from the Kiln API
301	const estimatedCompletionTime =
302	transaction.executionDate.getTime() +	×
303	networkStats.estimated_exit_time_seconds * 1000;
304
305	return Date.now() <= estimatedCompletionTime	×
306	? StakingValidatorsExitStatus.RequestPending
307	: StakingValidatorsExitStatus.ReadyToWithdraw;
308	}
309	/**
310	* Gets the total value to withdraw from the native staking deployment
311	* based on the amount of publicKey items in the transaction data.
312	*
313	* Each publicKey item represents a validator to withdraw, and each
314	* native staking validator has a fixed amount of 32 ETH to withdraw.
315	*
316	* @param data - the decoded data of the transaction
317	* @param chain - the chain where the native staking deployment lives
318	* @returns the total value to withdraw from the native staking deployment
319	*/
320	private getValueFromDataDecoded(data: DataDecoded, chain: Chain): number {
321	if (data.method === 'requestValidatorsExit') {	×
322	const publicKeys =
323	data.parameters?.filter(	×
324	(parameter) => parameter.name === '_publicKeys',	×
325	) ?? [];
326	const decimals = chain.nativeCurrency.decimals;	×
327	return (	×
328	publicKeys.length *
329	Math.pow(10, decimals) *
330	NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR
331	);
332	}
333
334	return 0;	×
335	}
336
337	private getPublicKeysFromDataDecoded(data: DataDecoded): `0x${string}`[] {
338	const publicKeys =
339	data.parameters?.filter(	×
340	(parameter) => parameter.name === '_publicKeys',	×
341	) ?? [];
342	return publicKeys.map((publicKey) => publicKey.value as `0x${string}`);	×
343	}
344	}
345
346	@Module({
347	imports: [StakingRepositoryModule, ChainsRepositoryModule],
348	providers: [NativeStakingMapper],
349	exports: [NativeStakingMapper],
350	})
351	export class NativeStakingMapperModule {}	16✔

safe-global / safe-client-gateway / 10685102512

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