10828474766

Committed 12 Sep 2024 08:43AM UTC coverage: 90.765% (-0.2%) from 91.002%

Build # 10828474766

Build Type

push

github

Committed by

web-flow

Commit Message

Get claimable rewards from transaction data (#1913)

- Adds a `rewards` field to the related entities.
- Creates a new `KilnDecoder.KilnPublicKeyLength` constant, to split the string of concatenated public keys.

Run Details

2581 of 3214 branches covered (80.3%)

Branch coverage included in aggregate %.

39 of 47 new or added lines in 9 files covered. (82.98%)

1 existing line in 1 file now uncovered.

8289 of 8762 relevant lines covered (94.6%)

446.56 hits per line

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

91.34

/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 { KilnDecoder } from '@/domain/staking/contracts/decoders/kiln-decoder.helper';
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';
import { isHex } from 'viem';

@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.transaction - the transaction object for the validators exit
   * @param args.dataDecoded - the decoded data of the transaction
   * @returns {@link NativeStakingValidatorsExitTransactionInfo} for the given native staking deployment
   */
  public async mapValidatorsExitInfo(args: {
    chainId: string;
    to: `0x${string}`;
    transaction: MultisigTransaction | ModuleTransaction | null;
    dataDecoded: DataDecoded;
  }): 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 numValidators = this.getNumValidatorsFromDataDecoded(
      args.dataDecoded,
    );
    const value = this.getValueFromNumValidators(numValidators, chain);
    const rewards = await this.getRewardsFromDataDecoded(
      args.dataDecoded,
      chain,
    );

    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,
      rewards: getNumberString(rewards),
      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.transaction - the transaction object for the withdraw
   * @param args.dataDecoded - the decoded data of the transaction
   * @returns {@link NativeStakingWithdrawTransactionInfo} for the given native staking deployment
   */
  public async mapWithdrawInfo(args: {
    chainId: string;
    to: `0x${string}`;
    transaction: MultisigTransaction | ModuleTransaction | null;
    dataDecoded: DataDecoded;
  }): 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);
    const numValidators = this.getNumValidatorsFromDataDecoded(
      args.dataDecoded,
    );
    const value = this.getValueFromNumValidators(numValidators, chain);
    const rewards = await this.getRewardsFromDataDecoded(
      args.dataDecoded,
      chain,
    );

    return new NativeStakingWithdrawTransactionInfo({
      value: getNumberString(value),
      rewards: getNumberString(rewards),
      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 value staked in the native staking deployment based on the number of validators.
   * Each validator has a fixed amount of 32 ETH staked.
   *
   * @param numValidators - the number of validators
   * @param chain - the chain where the native staking deployment lives
   * @returns - the value staked in the native staking deployment
   */
  private getValueFromNumValidators(
    numValidators: number,
    chain: Chain,
  ): number {
    const decimals = chain.nativeCurrency.decimals;
    return (
      numValidators *
      Math.pow(10, decimals) *
      NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR
    );
  }

  // TODO: move the following private functions to KilnApi/StakingRepository.

  /**
   * Gets the rewards to withdraw from the native staking deployment
   * based on the length of the publicKeys field in the transaction data.
   *
   * Each {@link KilnDecoder.KilnPublicKeyLength} characters represent 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 rewards to withdraw from the native staking deployment
   */
  private async getRewardsFromDataDecoded(
    data: DataDecoded,
    chain: Chain,
  ): Promise<number> {
    const publicKeys = this.getPublicKeysFromDataDecoded(data);
    if (!publicKeys) {
      return 0;
    }
    const stakes = await this.stakingRepository.getStakes({
      chainId: chain.chainId,
      validatorsPublicKeys: this.splitPublicKeys(publicKeys).join(','),
    });
    return stakes.reduce((acc, stake) => acc + Number(stake.rewards), 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}` | null {
    const publicKeys = data.parameters?.find(
      (parameter) => parameter.name === '_publicKeys',
    );
    return isHex(publicKeys?.value) ? publicKeys.value : null;
  }

  private getNumValidatorsFromDataDecoded(data: DataDecoded): number {
    const publicKeys = this.getPublicKeysFromDataDecoded(data);
    if (!publicKeys) {
      return 0;
    }
    return Math.floor(publicKeys.length / KilnDecoder.KilnPublicKeyLength);
  }

  /**
   * Splits the public keys into an array of public keys.
   *
   * Each {@link KilnDecoder.KilnPublicKeyLength} characters represent a validator to withdraw, so the public keys
   * are split into an array of strings of length {@link KilnDecoder.KilnPublicKeyLength}. The initial `0x` is removed.
   *
   * @param publicKeys - the public keys to split
   * @returns
   */
  private splitPublicKeys(publicKeys: `0x${string}`): string[] {
    const publicKeysString = publicKeys.slice(2);
    const publicKeysArray = [];
    for (
      let i = 0;
      i < publicKeysString.length;
      i += KilnDecoder.KilnPublicKeyLength
    ) {
      publicKeysArray.push(
        `${publicKeysString.slice(i, i + KilnDecoder.KilnPublicKeyLength)}`,
      );
    }
    return publicKeysArray;
  }
}

@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 {	106✔
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';	106✔
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 { KilnDecoder } from '@/domain/staking/contracts/decoders/kiln-decoder.helper';	106✔
13	import { IStakingRepository } from '@/domain/staking/staking.repository.interface';	106✔
14	import { StakingRepositoryModule } from '@/domain/staking/staking.repository.module';	106✔
15	import { NULL_ADDRESS } from '@/routes/common/constants';	106✔
16	import { NativeStakingDepositTransactionInfo } from '@/routes/transactions/entities/staking/native-staking-deposit-info.entity';	106✔
17	import { NativeStakingValidatorsExitTransactionInfo } from '@/routes/transactions/entities/staking/native-staking-validators-exit-info.entity';	106✔
18	import { NativeStakingWithdrawTransactionInfo } from '@/routes/transactions/entities/staking/native-staking-withdraw-info.entity';	106✔
19	import {	106✔
20	StakingDepositStatus,
21	StakingValidatorsExitStatus,
22	} from '@/routes/transactions/entities/staking/staking.entity';
23	import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';	106✔
24	import { Inject, Injectable, Module, NotFoundException } from '@nestjs/common';	106✔
25	import { isHex } from 'viem';	106✔
26
27	@Injectable()
28	export class NativeStakingMapper {	106✔
29	private static readonly ETH_ETHERS_PER_VALIDATOR = 32;	106✔
30
31	constructor(
32	@Inject(IStakingRepository)
33	private readonly stakingRepository: IStakingRepository,	1,698✔
34	@Inject(IChainsRepository)
35	private readonly chainsRepository: IChainsRepository,	1,698✔
36	) {}
37
38	/**
39	* Maps the {@link NativeStakingDepositTransactionInfo} for the given
40	* native staking deployment's `deposit` call
41	*
42	* @param args.chainId - the chain ID of the native staking deployment
43	* @param args.to - the address of the native staking deployment
44	* @param args.value - the value of the deposit transaction
45	* @param args.isConfirmed - whether the deposit transaction is confirmed
46	* @param args.depositExecutionDate - the date when the deposit transaction was executed
47	*
48	* @returns {@link NativeStakingDepositTransactionInfo} for the given native staking deployment
49	*/
50	public async mapDepositInfo(args: {
51	chainId: string;
52	to: `0x${string}`;
53	value: string \| null;
54	isConfirmed: boolean;
55	depositExecutionDate: Date \| null;
56	}): Promise<NativeStakingDepositTransactionInfo> {
57	const [chain, deployment] = await Promise.all([	28✔
58	this.chainsRepository.getChain(args.chainId),
59	this.stakingRepository.getDeployment({
60	chainId: args.chainId,
61	address: args.to,
62	}),
63	]);
64	this.validateDeployment(deployment);	28✔
65
66	const [nativeStakingStats, networkStats] = await Promise.all([	20✔
67	this.stakingRepository.getDedicatedStakingStats(args.chainId),
68	this.stakingRepository.getNetworkStats(args.chainId),
69	]);
70
71	const value = args.value ? Number(args.value) : 0;	14✔
72	const numValidators = Math.floor(	14✔
73	value /
74	Math.pow(10, chain.nativeCurrency.decimals) /
75	NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR,
76	);
77	const fee = deployment.product_fee ? Number(deployment.product_fee) : 0;	14!
78	// NRR = GRR * (1 - service_fees)
79	// Kiln also uses last_30d field, with product_fee
80	const nrr = nativeStakingStats.gross_apy.last_30d * (1 - fee);	14✔
81	const expectedAnnualReward = (nrr / 100) * value;	14✔
82	const expectedMonthlyReward = expectedAnnualReward / 12;	14✔
83	const expectedFiatAnnualReward =
84	(expectedAnnualReward * (networkStats.eth_price_usd ?? 0)) /	14!
85	Math.pow(10, chain.nativeCurrency.decimals);
86	const expectedFiatMonthlyReward = expectedFiatAnnualReward / 12;	14✔
87
88	return new NativeStakingDepositTransactionInfo({	14✔
89	status: this.mapDepositStatus(
90	networkStats,
91	args.isConfirmed,
92	args.depositExecutionDate,
93	),
94	estimatedEntryTime: networkStats.estimated_entry_time_seconds,
95	estimatedExitTime: networkStats.estimated_exit_time_seconds,
96	estimatedWithdrawalTime: networkStats.estimated_withdrawal_time_seconds,
97	fee,
98	monthlyNrr: nrr / 12,
99	annualNrr: nrr,
100	value: getNumberString(value),
101	numValidators,
102	expectedAnnualReward: getNumberString(expectedAnnualReward),
103	expectedMonthlyReward: getNumberString(expectedMonthlyReward),
104	expectedFiatAnnualReward,
105	expectedFiatMonthlyReward,
106	// tokenInfo is set to the native currency of the chain for native staking deposits
107	tokenInfo: new TokenInfo({
108	address: NULL_ADDRESS,
109	decimals: chain.nativeCurrency.decimals,
110	logoUri: chain.nativeCurrency.logoUri,
111	name: chain.nativeCurrency.name,
112	symbol: chain.nativeCurrency.symbol,
113	trusted: true,
114	}),
115	});
116	}
117
118	/**
119	* Maps the {@link NativeStakingValidatorsExitTransactionInfo} for the given
120	* native staking `requestValidatorsExit` transaction.
121	*
122	* @param args.chainId - the chain ID of the native staking deployment
123	* @param args.to - the address of the native staking deployment
124	* @param args.transaction - the transaction object for the validators exit
125	* @param args.dataDecoded - the decoded data of the transaction
126	* @returns {@link NativeStakingValidatorsExitTransactionInfo} for the given native staking deployment
127	*/
128	public async mapValidatorsExitInfo(args: {
129	chainId: string;
130	to: `0x${string}`;
131	transaction: MultisigTransaction \| ModuleTransaction \| null;
132	dataDecoded: DataDecoded;
133	}): Promise<NativeStakingValidatorsExitTransactionInfo> {
134	const [chain, deployment] = await Promise.all([	22✔
135	this.chainsRepository.getChain(args.chainId),
136	this.stakingRepository.getDeployment({
137	chainId: args.chainId,
138	address: args.to,
139	}),
140	]);
141	this.validateDeployment(deployment);	22✔
142	const networkStats = await this.stakingRepository.getNetworkStats(	14✔
143	args.chainId,
144	);
145	const numValidators = this.getNumValidatorsFromDataDecoded(	14✔
146	args.dataDecoded,
147	);
148	const value = this.getValueFromNumValidators(numValidators, chain);	14✔
149	const rewards = await this.getRewardsFromDataDecoded(	14✔
150	args.dataDecoded,
151	chain,
152	);
153
154	return new NativeStakingValidatorsExitTransactionInfo({	12✔
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	rewards: getNumberString(rewards),
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.transaction - the transaction object for the withdraw
179	* @param args.dataDecoded - the decoded data of the transaction
180	* @returns {@link NativeStakingWithdrawTransactionInfo} for the given native staking deployment
181	*/
182	public async mapWithdrawInfo(args: {
183	chainId: string;
184	to: `0x${string}`;
185	transaction: MultisigTransaction \| ModuleTransaction \| null;
186	dataDecoded: DataDecoded;
187	}): Promise<NativeStakingWithdrawTransactionInfo> {
188	const [chain, deployment] = await Promise.all([	16✔
189	this.chainsRepository.getChain(args.chainId),
190	this.stakingRepository.getDeployment({
191	chainId: args.chainId,
192	address: args.to,
193	}),
194	]);
195	this.validateDeployment(deployment);	16✔
196	const numValidators = this.getNumValidatorsFromDataDecoded(	8✔
197	args.dataDecoded,
198	);
199	const value = this.getValueFromNumValidators(numValidators, chain);	8✔
200	const rewards = await this.getRewardsFromDataDecoded(	8✔
201	args.dataDecoded,
202	chain,
203	);
204
205	return new NativeStakingWithdrawTransactionInfo({	6✔
206	value: getNumberString(value),
207	rewards: getNumberString(rewards),
208	tokenInfo: new TokenInfo({
209	address: NULL_ADDRESS,
210	decimals: chain.nativeCurrency.decimals,
211	logoUri: chain.nativeCurrency.logoUri,
212	name: chain.nativeCurrency.name,
213	symbol: chain.nativeCurrency.symbol,
214	trusted: true,
215	}),
216	});
217	}
218
219	private validateDeployment(deployment: Deployment): void {
220	if (	66✔
221	deployment.product_type !== 'dedicated' \|\|	87✔
222	deployment.chain === 'unknown' \|\|
223	deployment.status === 'unknown'
224	) {
225	throw new NotFoundException('Native staking deployment not found');	24✔
226	}
227	}
228
229	/**
230	* Maps the {@link StakingDepositStatus} for the given native staking deployment's `deposit` call.
231	* - If the deposit transaction is not confirmed, the status is {@link StakingDepositStatus.SignatureNeeded}.
232	* - If the deposit transaction is confirmed but the deposit execution date is not available,
233	* the status is {@link StakingDepositStatus.AwaitingExecution}.
234	* - If the deposit execution date is available, the status is {@link StakingDepositStatus.AwaitingEntry} if the current
235	* date is before the estimated entry time, otherwise the status is {@link StakingDepositStatus.ValidationStarted}.
236	*
237	* @param networkStats - the network stats for the chain where the native staking deployment lives.
238	* @param isConfirmed - whether the deposit transaction is confirmed.
239	* @param depositExecutionDate - the date when the deposit transaction was executed.
240	* @returns - the {@link StakingDepositStatus} status of the deposit transaction.
241	*/
242	private mapDepositStatus(
243	networkStats: NetworkStats,
244	isConfirmed: boolean,
245	depositExecutionDate: Date \| null,
246	): StakingDepositStatus {
247	if (!isConfirmed) {	14✔
248	return StakingDepositStatus.SignatureNeeded;	8✔
249	}
250
251	if (!depositExecutionDate) {	6✔
252	return StakingDepositStatus.AwaitingExecution;	2✔
253	}
254
255	const estimatedDepositEntryTime =
256	depositExecutionDate.getTime() +	4✔
257	networkStats.estimated_entry_time_seconds * 1000;
258
259	return Date.now() <= estimatedDepositEntryTime	4✔
260	? StakingDepositStatus.AwaitingEntry
261	: StakingDepositStatus.ValidationStarted;
262	}
263
264	/**
265	* Maps the {@link StakingValidatorsExitStatus} for the given native staking `requestValidatorsExit` transaction.
266	* - If the transaction is not confirmed, the status is {@link StakingValidatorsExitStatus.SignatureNeeded}.
267	* - If the transaction is confirmed but the execution date is not available, the status
268	* is {@link StakingValidatorsExitStatus.AwaitingExecution}.
269	* - If the execution date is available, the status is {@link StakingValidatorsExitStatus.RequestPending} if the
270	* current date is before the estimated exit time, otherwise the status is {@link StakingValidatorsExitStatus.ReadyToWithdraw}.
271	*
272	* @param networkStats - the network stats for the chain where the native staking deployment lives.
273	* @param transaction - the validators exit transaction.
274	* @returns - the {@link StakingValidatorsExitStatus} status of the validators exit transaction.
275	*/
276	private mapValidatorsExitStatus(
277	networkStats: NetworkStats,
278	transaction: MultisigTransaction \| ModuleTransaction \| null,
279	): StakingValidatorsExitStatus {
280	const isConfirmed =
281	transaction &&	12✔
282	'confirmations' in transaction &&
283	!!transaction.confirmations &&
284	transaction.confirmations.length >= transaction.confirmationsRequired;
285
286	if (!isConfirmed) {	12✔
287	return StakingValidatorsExitStatus.SignatureNeeded;	6✔
288	}
289
290	if (!transaction.executionDate) {	6✔
291	return StakingValidatorsExitStatus.AwaitingExecution;	2✔
292	}
293
294	const estimatedCompletionTime =
295	transaction.executionDate.getTime() +	4✔
296	networkStats.estimated_exit_time_seconds * 1000;
297
298	return Date.now() <= estimatedCompletionTime	4✔
299	? StakingValidatorsExitStatus.RequestPending
300	: StakingValidatorsExitStatus.ReadyToWithdraw;
301	}
302
303	/**
304	* Gets the value staked in the native staking deployment based on the number of validators.
305	* Each validator has a fixed amount of 32 ETH staked.
306	*
307	* @param numValidators - the number of validators
308	* @param chain - the chain where the native staking deployment lives
309	* @returns - the value staked in the native staking deployment
310	*/
311	private getValueFromNumValidators(
312	numValidators: number,
313	chain: Chain,
314	): number {
315	const decimals = chain.nativeCurrency.decimals;	22✔
316	return (	22✔
317	numValidators *
318	Math.pow(10, decimals) *
319	NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR
320	);
321	}
322
323	// TODO: move the following private functions to KilnApi/StakingRepository.
324
325	/**
326	* Gets the rewards to withdraw from the native staking deployment
327	* based on the length of the publicKeys field in the transaction data.
328	*
329	* Each {@link KilnDecoder.KilnPublicKeyLength} characters represent a validator to withdraw,
330	* and each native staking validator has a fixed amount of 32 ETH to withdraw.
331	*
332	* @param data - the decoded data of the transaction
333	* @param chain - the chain where the native staking deployment lives
334	* @returns the rewards to withdraw from the native staking deployment
335	*/
336	private async getRewardsFromDataDecoded(
337	data: DataDecoded,
338	chain: Chain,
339	): Promise<number> {
340	const publicKeys = this.getPublicKeysFromDataDecoded(data);	22✔
341	if (!publicKeys) {	22!
NEW 342	return 0;	×
343	}
344	const stakes = await this.stakingRepository.getStakes({	22✔
345	chainId: chain.chainId,
346	validatorsPublicKeys: this.splitPublicKeys(publicKeys).join(','),
347	});
348	return stakes.reduce((acc, stake) => acc + Number(stake.rewards), 0);	32✔
349	}
350
351	/**
352	* Gets the public keys from the transaction decoded data.
353	* @param data - the transaction decoded data.
354	* @returns the public keys from the transaction decoded data.
355	*/
356	private getPublicKeysFromDataDecoded(
357	data: DataDecoded,
358	): `0x${string}` \| null {
359	const publicKeys = data.parameters?.find(	44!
360	(parameter) => parameter.name === '_publicKeys',	44✔
361	);
362	return isHex(publicKeys?.value) ? publicKeys.value : null;	44!
363	}
364
365	private getNumValidatorsFromDataDecoded(data: DataDecoded): number {
366	const publicKeys = this.getPublicKeysFromDataDecoded(data);	22✔
367	if (!publicKeys) {	22!
NEW 368	return 0;	×
369	}
370	return Math.floor(publicKeys.length / KilnDecoder.KilnPublicKeyLength);	22✔
371	}
372
373	/**
374	* Splits the public keys into an array of public keys.
375	*
376	* Each {@link KilnDecoder.KilnPublicKeyLength} characters represent a validator to withdraw, so the public keys
377	* are split into an array of strings of length {@link KilnDecoder.KilnPublicKeyLength}. The initial `0x` is removed.
378	*
379	* @param publicKeys - the public keys to split
380	* @returns
381	*/
382	private splitPublicKeys(publicKeys: `0x${string}`): string[] {
383	const publicKeysString = publicKeys.slice(2);	22✔
384	const publicKeysArray = [];	22✔
385	for (	22✔
386	let i = 0;	22✔
387	i < publicKeysString.length;
388	i += KilnDecoder.KilnPublicKeyLength
389	) {
390	publicKeysArray.push(	52✔
391	`${publicKeysString.slice(i, i + KilnDecoder.KilnPublicKeyLength)}`,
392	);
393	}
394	return publicKeysArray;	22✔
395	}
396	}
397
398	@Module({
399	imports: [StakingRepositoryModule, ChainsRepositoryModule],
400	providers: [NativeStakingMapper],
401	exports: [NativeStakingMapper],
402	})
403	export class NativeStakingMapperModule {}	106✔

safe-global / safe-client-gateway / 10828474766

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