10699515830

Committed 04 Sep 2024 10:05AM UTC coverage: 46.199% (+0.008%) from 46.191%

Build # 10699515830

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 %.

4 of 10 new or added lines in 1 file covered. (40.0%)

8 existing lines in 2 files now uncovered.

4837 of 8431 relevant lines covered (57.37%)

12.19 hits per line

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

11.19

/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) {
      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 `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,
      }),
    ]);
    if (!deployment) {
      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 `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,
      }),
    ]);
    if (!deployment) {
      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)
        : [];

      if (validatorsPublicKeys.length > 0) {
        const stakes = await this.stakingRepository.getStakes({
          chainId: args.chainId,
          validatorsPublicKeys,
        });
        value = stakes.reduce((sum, stake) => {
          const reward = Number(stake.rewards);
          return sum + (isNaN(reward) ? 0 : reward);
        }, 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;
  }

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

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