10736068886

Committed 06 Sep 2024 09:35AM UTC coverage: 46.169% (+0.3%) from 45.889%

Build # 10736068886

Build Type

Pull #1895

github

Committed by

web-flow

Commit Message

Rename StakingStatus enums (#1899)

- Renames `StakingStatus` to `StakingDepositStatus` as it only contains the statuses for `deposit` transactions.
- Renames `StakingStatusInfo` to `StakingDepositStatusInfo` as it only contains the statuses for `deposit` transactions.
- Removes `RequestedExit`, `Unknown` and `Withdrawn` statuses from `StakingDepositStatus` as they are not used anywhere.

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

Run Details

499 of 3126 branches covered (15.96%)

Branch coverage included in aggregate %.

4 of 16 new or added lines in 5 files covered. (25.0%)

2 existing lines in 2 files now uncovered.

4834 of 8425 relevant lines covered (57.38%)

12.18 hits per line

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

23.68

/src/routes/transactions/helpers/kiln-native-staking.helper.ts

import { IStakingRepository } from '@/domain/staking/staking.repository.interface';
import { StakingRepositoryModule } from '@/domain/staking/staking.repository.module';
import {
  TransactionFinder,
  TransactionFinderModule,
} from '@/routes/transactions/helpers/transaction-finder.helper';
import { Inject, Injectable, Module } from '@nestjs/common';
import { toFunctionSelector } from 'viem';

@Injectable()
export class KilnNativeStakingHelper {
  constructor(
    private readonly transactionFinder: TransactionFinder,
    @Inject(IStakingRepository)
    private readonly stakingRepository: IStakingRepository,
  ) {}

  public async findDeposit(args: {
    chainId: string;
    to?: `0x${string}`;
    data: `0x${string}`;
  }): Promise<{
    to: `0x${string}`;
    data: `0x${string}`;
  } | null> {
    return this.findTransactionAndCheckDeployment({
      ...args,
      selector: toFunctionSelector('function deposit() external payable'),
    });
  }

  public async findValidatorsExit(args: {
    chainId: string;
    to?: `0x${string}`;
    data: `0x${string}`;
  }): Promise<{
    to: `0x${string}`;
    data: `0x${string}`;
  } | null> {
    return this.findTransactionAndCheckDeployment({
      ...args,
      selector: toFunctionSelector(
        'function requestValidatorsExit(bytes) external',
      ),
    });
  }

  public async findWithdraw(args: {
    chainId: string;
    to?: `0x${string}`;
    data: `0x${string}`;
  }): Promise<{
    to: `0x${string}`;
    data: `0x${string}`;
  } | null> {
    return this.findTransactionAndCheckDeployment({
      ...args,
      selector: toFunctionSelector(
        'function batchWithdrawCLFee(bytes) external',
      ),
    });
  }

  /**
   * Check the transaction and the deployment to see if it is a valid staking transaction.
   * We need to check against the deployment as some function signatures have common function names, e.g. deposit.
   */
  private async findTransactionAndCheckDeployment(args: {
    chainId: string;
    to?: `0x${string}`;
    data: `0x${string}`;
    selector: string;
  }): Promise<{
    to: `0x${string}`;
    data: `0x${string}`;
  } | null> {
    const transaction = this.transactionFinder.findTransaction(
      (transaction) => transaction.data.startsWith(args.selector),
      args,
    );

    if (!transaction?.to) {
      return null;
    }

    const deployment = await this.stakingRepository
      .getDeployment({
        chainId: args.chainId,
        address: transaction.to,
      })
      .catch(() => null);

    if (
      deployment?.product_type !== 'dedicated' &&
      deployment?.chain !== 'unknown'
    ) {
      return null;
    }

    return {
      to: transaction.to,
      data: transaction.data,
    };
  }
}

@Module({
  imports: [TransactionFinderModule, StakingRepositoryModule],
  providers: [KilnNativeStakingHelper],
  exports: [KilnNativeStakingHelper],
})
export class KilnNativeStakingHelperModule {}

1	import { IStakingRepository } from '@/domain/staking/staking.repository.interface';	16✔
2	import { StakingRepositoryModule } from '@/domain/staking/staking.repository.module';	16✔
3	import {	16✔
4	TransactionFinder,
5	TransactionFinderModule,
6	} from '@/routes/transactions/helpers/transaction-finder.helper';
7	import { Inject, Injectable, Module } from '@nestjs/common';	16✔
8	import { toFunctionSelector } from 'viem';	16✔
9
10	@Injectable()
11	export class KilnNativeStakingHelper {	16✔
12	constructor(
13	private readonly transactionFinder: TransactionFinder,	16✔
14	@Inject(IStakingRepository)
15	private readonly stakingRepository: IStakingRepository,	16✔
16	) {}
17
18	public async findDeposit(args: {
19	chainId: string;
20	to?: `0x${string}`;
21	data: `0x${string}`;
22	}): Promise<{
23	to: `0x${string}`;
24	data: `0x${string}`;
25	} \| null> {
NEW 26	return this.findTransactionAndCheckDeployment({	×
27	...args,
28	selector: toFunctionSelector('function deposit() external payable'),
29	});
30	}
31
32	public async findValidatorsExit(args: {
33	chainId: string;
34	to?: `0x${string}`;
35	data: `0x${string}`;
36	}): Promise<{
37	to: `0x${string}`;
38	data: `0x${string}`;
39	} \| null> {
NEW 40	return this.findTransactionAndCheckDeployment({	×
41	...args,
42	selector: toFunctionSelector(
43	'function requestValidatorsExit(bytes) external',
44	),
45	});
46	}
47
48	public async findWithdraw(args: {
49	chainId: string;
50	to?: `0x${string}`;
51	data: `0x${string}`;
52	}): Promise<{
53	to: `0x${string}`;
54	data: `0x${string}`;
55	} \| null> {
NEW 56	return this.findTransactionAndCheckDeployment({	×
57	...args,
58	selector: toFunctionSelector(
59	'function batchWithdrawCLFee(bytes) external',
60	),
61	});
62	}
63
64	/**
65	* Check the transaction and the deployment to see if it is a valid staking transaction.
66	* We need to check against the deployment as some function signatures have common function names, e.g. deposit.
67	*/
68	private async findTransactionAndCheckDeployment(args: {
69	chainId: string;
70	to?: `0x${string}`;
71	data: `0x${string}`;
72	selector: string;
73	}): Promise<{
74	to: `0x${string}`;
75	data: `0x${string}`;
76	} \| null> {
77	const transaction = this.transactionFinder.findTransaction(	×
NEW 78	(transaction) => transaction.data.startsWith(args.selector),	×
79	args,
80	);
81
82	if (!transaction?.to) {	×
83	return null;	×
84	}
85
UNCOV 86	const deployment = await this.stakingRepository	×
87	.getDeployment({
88	chainId: args.chainId,
89	address: transaction.to,
90	})
91	.catch(() => null);	×
92
93	if (	×
94	deployment?.product_type !== 'dedicated' &&	×
95	deployment?.chain !== 'unknown'	×
96	) {
97	return null;	×
98	}
99
100	return {	×
101	to: transaction.to,
102	data: transaction.data,
103	};
104	}
105	}
106
107	@Module({
108	imports: [TransactionFinderModule, StakingRepositoryModule],
109	providers: [KilnNativeStakingHelper],
110	exports: [KilnNativeStakingHelper],
111	})
112	export class KilnNativeStakingHelperModule {}	16✔

safe-global / safe-client-gateway / 10736068886

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