10994492682

Committed 23 Sep 2024 12:41PM UTC coverage: 90.795% (+0.06%) from 90.74%

Build # 10994492682

Build Type

Pull #1940

github

Committed by

PooyaRaki

Commit Message

restructure domain/notifications

Pull Request Pull Request #1940: restructure notifications

Run Details

2548 of 3177 branches covered (80.2%)

Branch coverage included in aggregate %.

23 of 23 new or added lines in 11 files covered. (100.0%)

2 existing lines in 1 file now uncovered.

8312 of 8784 relevant lines covered (94.63%)

445.79 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.safeAddress - the Safe staking
   * @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;
    safeAddress: `0x${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({
      dataDecoded: args.dataDecoded,
      chainId: args.chainId,
      safeAddress: args.safeAddress,
    });

    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.safeAddress - the Safe staking
   * @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;
    safeAddress: `0x${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({
      dataDecoded: args.dataDecoded,
      chainId: args.chainId,
      safeAddress: args.safeAddress,
    });

    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 + withdrawal 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 +
      networkStats.estimated_withdrawal_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
    );
  }

  /**
   * 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 dataDecoded - the decoded data of the transaction
   * @param chainId - the ID of the chain where the native staking deployment lives
   * @param safeAddress - the Safe staking
   * @returns the rewards to withdraw from the native staking deployment
   */
  private async getRewardsFromDataDecoded(args: {
    dataDecoded: DataDecoded;
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<number> {
    const publicKeys = this.getPublicKeysFromDataDecoded(args.dataDecoded);
    if (!publicKeys) {
      return 0;
    }
    const stakes = await this.stakingRepository.getStakes({
      chainId: args.chainId,
      safeAddress: args.safeAddress,
      validatorsPublicKeys: this.splitPublicKeys(publicKeys),
    });
    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(
      // Ignore the `0x` prefix
      (publicKeys.length - 2) / 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}.
   *
   * @param publicKeys - the public keys to split
   * @returns
   */
  private splitPublicKeys(publicKeys: `0x${string}`): `0x${string}`[] {
    // Remove initial `0x` of decoded `_publicKeys`
    const publicKeysString = publicKeys.slice(2);
    const publicKeysArray: `0x${string}`[] = [];
    for (
      let i = 0;
      i < publicKeysString.length;
      i += KilnDecoder.KilnPublicKeyLength
    ) {
      publicKeysArray.push(
        `0x${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,702✔
34	@Inject(IChainsRepository)
35	private readonly chainsRepository: IChainsRepository,	1,702✔
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.safeAddress - the Safe staking
124	* @param args.to - the address of the native staking deployment
125	* @param args.transaction - the transaction object for the validators exit
126	* @param args.dataDecoded - the decoded data of the transaction
127	* @returns {@link NativeStakingValidatorsExitTransactionInfo} for the given native staking deployment
128	*/
129	public async mapValidatorsExitInfo(args: {
130	chainId: string;
131	safeAddress: `0x${string}`;
132	to: `0x${string}`;
133	transaction: MultisigTransaction \| ModuleTransaction \| null;
134	dataDecoded: DataDecoded;
135	}): Promise<NativeStakingValidatorsExitTransactionInfo> {
136	const [chain, deployment] = await Promise.all([	22✔
137	this.chainsRepository.getChain(args.chainId),
138	this.stakingRepository.getDeployment({
139	chainId: args.chainId,
140	address: args.to,
141	}),
142	]);
143	this.validateDeployment(deployment);	22✔
144	const networkStats = await this.stakingRepository.getNetworkStats(	14✔
145	args.chainId,
146	);
147	const numValidators = this.getNumValidatorsFromDataDecoded(	14✔
148	args.dataDecoded,
149	);
150	const value = this.getValueFromNumValidators(numValidators, chain);	14✔
151	const rewards = await this.getRewardsFromDataDecoded({	14✔
152	dataDecoded: args.dataDecoded,
153	chainId: args.chainId,
154	safeAddress: args.safeAddress,
155	});
156
157	return new NativeStakingValidatorsExitTransactionInfo({	12✔
158	status: this.mapValidatorsExitStatus(networkStats, args.transaction),
159	estimatedExitTime: networkStats.estimated_exit_time_seconds,
160	estimatedWithdrawalTime: networkStats.estimated_withdrawal_time_seconds,
161	value: getNumberString(value),
162	numValidators,
163	rewards: getNumberString(rewards),
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.safeAddress - the Safe staking
181	* @param args.to - the address of the native staking deployment
182	* @param args.transaction - the transaction object for the withdraw
183	* @param args.dataDecoded - the decoded data of the transaction
184	* @returns {@link NativeStakingWithdrawTransactionInfo} for the given native staking deployment
185	*/
186	public async mapWithdrawInfo(args: {
187	chainId: string;
188	safeAddress: `0x${string}`;
189	to: `0x${string}`;
190	transaction: MultisigTransaction \| ModuleTransaction \| null;
191	dataDecoded: DataDecoded;
192	}): Promise<NativeStakingWithdrawTransactionInfo> {
193	const [chain, deployment] = await Promise.all([	16✔
194	this.chainsRepository.getChain(args.chainId),
195	this.stakingRepository.getDeployment({
196	chainId: args.chainId,
197	address: args.to,
198	}),
199	]);
200	this.validateDeployment(deployment);	16✔
201	const numValidators = this.getNumValidatorsFromDataDecoded(	8✔
202	args.dataDecoded,
203	);
204	const value = this.getValueFromNumValidators(numValidators, chain);	8✔
205	const rewards = await this.getRewardsFromDataDecoded({	8✔
206	dataDecoded: args.dataDecoded,
207	chainId: args.chainId,
208	safeAddress: args.safeAddress,
209	});
210
211	return new NativeStakingWithdrawTransactionInfo({	6✔
212	value: getNumberString(value),
213	rewards: getNumberString(rewards),
214	tokenInfo: new TokenInfo({
215	address: NULL_ADDRESS,
216	decimals: chain.nativeCurrency.decimals,
217	logoUri: chain.nativeCurrency.logoUri,
218	name: chain.nativeCurrency.name,
219	symbol: chain.nativeCurrency.symbol,
220	trusted: true,
221	}),
222	});
223	}
224
225	private validateDeployment(deployment: Deployment): void {
226	if (	66✔
227	deployment.product_type !== 'dedicated' \|\|	87✔
228	deployment.chain === 'unknown' \|\|
229	deployment.status === 'unknown'
230	) {
231	throw new NotFoundException('Native staking deployment not found');	24✔
232	}
233	}
234
235	/**
236	* Maps the {@link StakingDepositStatus} for the given native staking deployment's `deposit` call.
237	* - If the deposit transaction is not confirmed, the status is {@link StakingDepositStatus.SignatureNeeded}.
238	* - If the deposit transaction is confirmed but the deposit execution date is not available,
239	* the status is {@link StakingDepositStatus.AwaitingExecution}.
240	* - If the deposit execution date is available, the status is {@link StakingDepositStatus.AwaitingEntry} if the current
241	* date is before the estimated entry time, otherwise the status is {@link StakingDepositStatus.ValidationStarted}.
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 - the {@link StakingDepositStatus} status of the deposit transaction.
247	*/
248	private mapDepositStatus(
249	networkStats: NetworkStats,
250	isConfirmed: boolean,
251	depositExecutionDate: Date \| null,
252	): StakingDepositStatus {
253	if (!isConfirmed) {	14✔
254	return StakingDepositStatus.SignatureNeeded;	8✔
255	}
256
257	if (!depositExecutionDate) {	6✔
258	return StakingDepositStatus.AwaitingExecution;	2✔
259	}
260
261	const estimatedDepositEntryTime =
262	depositExecutionDate.getTime() +	4✔
263	networkStats.estimated_entry_time_seconds * 1000;
264
265	return Date.now() <= estimatedDepositEntryTime	4✔
266	? StakingDepositStatus.AwaitingEntry
267	: StakingDepositStatus.ValidationStarted;
268	}
269
270	/**
271	* Maps the {@link StakingValidatorsExitStatus} for the given native staking `requestValidatorsExit` transaction.
272	* - If the transaction is not confirmed, the status is {@link StakingValidatorsExitStatus.SignatureNeeded}.
273	* - If the transaction is confirmed but the execution date is not available, the status
274	* is {@link StakingValidatorsExitStatus.AwaitingExecution}.
275	* - If the execution date is available, the status is {@link StakingValidatorsExitStatus.RequestPending} if the
276	* current date is before the estimated exit + withdrawal time, otherwise the status is {@link StakingValidatorsExitStatus.ReadyToWithdraw}.
277	*
278	* @param networkStats - the network stats for the chain where the native staking deployment lives.
279	* @param transaction - the validators exit transaction.
280	* @returns - the {@link StakingValidatorsExitStatus} status of the validators exit transaction.
281	*/
282	private mapValidatorsExitStatus(
283	networkStats: NetworkStats,
284	transaction: MultisigTransaction \| ModuleTransaction \| null,
285	): StakingValidatorsExitStatus {
286	const isConfirmed =
287	transaction &&	12✔
288	'confirmations' in transaction &&
289	!!transaction.confirmations &&
290	transaction.confirmations.length >= transaction.confirmationsRequired;
291
292	if (!isConfirmed) {	12✔
293	return StakingValidatorsExitStatus.SignatureNeeded;	6✔
294	}
295
296	if (!transaction.executionDate) {	6✔
297	return StakingValidatorsExitStatus.AwaitingExecution;	2✔
298	}
299
300	const estimatedCompletionTime =
301	transaction.executionDate.getTime() +	4✔
302	networkStats.estimated_exit_time_seconds * 1000 +
303	networkStats.estimated_withdrawal_time_seconds * 1000;
304
305	return Date.now() <= estimatedCompletionTime	4✔
306	? StakingValidatorsExitStatus.RequestPending
307	: StakingValidatorsExitStatus.ReadyToWithdraw;
308	}
309
310	/**
311	* Gets the value staked in the native staking deployment based on the number of validators.
312	* Each validator has a fixed amount of 32 ETH staked.
313	*
314	* @param numValidators - the number of validators
315	* @param chain - the chain where the native staking deployment lives
316	* @returns - the value staked in the native staking deployment
317	*/
318	private getValueFromNumValidators(
319	numValidators: number,
320	chain: Chain,
321	): number {
322	const decimals = chain.nativeCurrency.decimals;	22✔
323	return (	22✔
324	numValidators *
325	Math.pow(10, decimals) *
326	NativeStakingMapper.ETH_ETHERS_PER_VALIDATOR
327	);
328	}
329
330	/**
331	* Gets the rewards to withdraw from the native staking deployment
332	* based on the length of the publicKeys field in the transaction data.
333	*
334	* Each {@link KilnDecoder.KilnPublicKeyLength} characters represent a validator to withdraw,
335	* and each native staking validator has a fixed amount of 32 ETH to withdraw.
336	*
337	* @param dataDecoded - the decoded data of the transaction
338	* @param chainId - the ID of the chain where the native staking deployment lives
339	* @param safeAddress - the Safe staking
340	* @returns the rewards to withdraw from the native staking deployment
341	*/
342	private async getRewardsFromDataDecoded(args: {
343	dataDecoded: DataDecoded;
344	chainId: string;
345	safeAddress: `0x${string}`;
346	}): Promise<number> {
347	const publicKeys = this.getPublicKeysFromDataDecoded(args.dataDecoded);	22✔
348	if (!publicKeys) {	22!
UNCOV 349	return 0;	×
350	}
351	const stakes = await this.stakingRepository.getStakes({	22✔
352	chainId: args.chainId,
353	safeAddress: args.safeAddress,
354	validatorsPublicKeys: this.splitPublicKeys(publicKeys),
355	});
356	return stakes.reduce((acc, stake) => acc + Number(stake.rewards), 0);	32✔
357	}
358
359	/**
360	* Gets the public keys from the transaction decoded data.
361	* @param data - the transaction decoded data.
362	* @returns the public keys from the transaction decoded data.
363	*/
364	private getPublicKeysFromDataDecoded(
365	data: DataDecoded,
366	): `0x${string}` \| null {
367	const publicKeys = data.parameters?.find(	44!
368	(parameter) => parameter.name === '_publicKeys',	44✔
369	);
370	return isHex(publicKeys?.value) ? publicKeys.value : null;	44!
371	}
372
373	private getNumValidatorsFromDataDecoded(data: DataDecoded): number {
374	const publicKeys = this.getPublicKeysFromDataDecoded(data);	22✔
375	if (!publicKeys) {	22!
UNCOV 376	return 0;	×
377	}
378	return Math.floor(	22✔
379	// Ignore the `0x` prefix
380	(publicKeys.length - 2) / KilnDecoder.KilnPublicKeyLength,
381	);
382	}
383
384	/**
385	* Splits the public keys into an array of public keys.
386	*
387	* Each {@link KilnDecoder.KilnPublicKeyLength} characters represent a validator to withdraw, so the public keys
388	* are split into an array of strings of length {@link KilnDecoder.KilnPublicKeyLength}.
389	*
390	* @param publicKeys - the public keys to split
391	* @returns
392	*/
393	private splitPublicKeys(publicKeys: `0x${string}`): `0x${string}`[] {
394	// Remove initial `0x` of decoded `_publicKeys`
395	const publicKeysString = publicKeys.slice(2);	22✔
396	const publicKeysArray: `0x${string}`[] = [];	22✔
397	for (	22✔
398	let i = 0;	22✔
399	i < publicKeysString.length;
400	i += KilnDecoder.KilnPublicKeyLength
401	) {
402	publicKeysArray.push(	52✔
403	`0x${publicKeysString.slice(i, i + KilnDecoder.KilnPublicKeyLength)}`,
404	);
405	}
406	return publicKeysArray;	22✔
407	}
408	}
409
410	@Module({
411	imports: [StakingRepositoryModule, ChainsRepositoryModule],
412	providers: [NativeStakingMapper],
413	exports: [NativeStakingMapper],
414	})
415	export class NativeStakingMapperModule {}	106✔

safe-global / safe-client-gateway / 10994492682

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