10775999258

Committed 09 Sep 2024 03:07PM UTC coverage: 46.165% (+0.3%) from 45.889%

Build # 10775999258

Build Type

Pull #1895

github

Committed by

hectorgomezv

Commit Message

Expose one KilnNativeStakingHelper function per native transaction type

Pull Request Pull Request #1895: Factorize Native Staking helpers and mappers common logic

Run Details

499 of 3126 branches covered (15.96%)

Branch coverage included in aggregate %.

6 of 23 new or added lines in 6 files covered. (26.09%)

6 existing lines in 2 files now uncovered.

4834 of 8426 relevant lines covered (57.37%)

12.19 hits per line

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

11.68

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

import { Deployment } from '@/datasources/staking-api/entities/deployment.entity';
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 {
  StakingDepositStatus,
  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,
      }),
    ]);
    this.validateDeployment(deployment);

    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 `requestValidatorsExit` transaction.
   *
   * @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
   */
  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,
      }),
    ]);
    this.validateDeployment(deployment);

    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 `batchWithdrawCLFee` transaction.
   *
   * @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
   */
  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,
      }),
    ]);
    this.validateDeployment(deployment);

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

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

      if (validatorsPublicKeys.length > 0) {
        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,
      }),
    });
  }

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

  /**
   * Maps the {@link StakingDepositStatus} for the given native staking deployment's `deposit` call.
   * - If the deposit transaction is not confirmed, the status is {@link StakingDepositStatus.SignatureNeeded}.
   * - If the deposit transaction is confirmed but the deposit execution date is not available,
   * the status is {@link StakingDepositStatus.AwaitingExecution}.
   * - If the deposit execution date is available, the status is {@link StakingDepositStatus.AwaitingEntry} if the current
   * date is before the estimated entry time, otherwise the status is {@link StakingDepositStatus.ValidationStarted}.
   *
   * @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 - the {@link StakingDepositStatus} status of the deposit transaction.
   */
  private mapDepositStatus(
    networkStats: NetworkStats,
    isConfirmed: boolean,
    depositExecutionDate: Date | null,
  ): StakingDepositStatus {
    if (!isConfirmed) {
      return StakingDepositStatus.SignatureNeeded;
    }

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

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

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

  /**
   * Maps the {@link StakingValidatorsExitStatus} for the given native staking `requestValidatorsExit` transaction.
   * - If the transaction is not confirmed, the status is {@link StakingValidatorsExitStatus.SignatureNeeded}.
   * - If the transaction is confirmed but the execution date is not available, the status
   * is {@link StakingValidatorsExitStatus.AwaitingExecution}.
   * - If the execution date is available, the status is {@link StakingValidatorsExitStatus.RequestPending} if the
   * current date is before the estimated exit time, otherwise the status is {@link StakingValidatorsExitStatus.ReadyToWithdraw}.
   *
   * @param networkStats - the network stats for the chain where the native staking deployment lives.
   * @param transaction - the validators exit transaction.
   * @returns - the {@link StakingValidatorsExitStatus} status of the validators exit transaction.
   */
  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;
    }

    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 = this.getPublicKeysFromDataDecoded(data);
      const decimals = chain.nativeCurrency.decimals;
      return (
        publicKeys.length *
        Math.pow(10, decimals) *
        NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR
      );
    }

    return 0;
  }

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

safe-global / safe-client-gateway / 10775999258

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