10456279889

Committed 19 Aug 2024 03:27PM UTC coverage: 46.252% (-0.6%) from 46.893%

Build # 10456279889

Build Type

Pull #1824

github

Committed by

iamacook

Commit Message

Mapper refactor

Pull Request Pull Request #1824: Staking confirmation screens

Run Details

491 of 3096 branches covered (15.86%)

Branch coverage included in aggregate %.

310 of 648 new or added lines in 35 files covered. (47.84%)

65 existing lines in 2 files now uncovered.

4853 of 8458 relevant lines covered (57.38%)

12.39 hits per line

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

15.0

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

import {
  BlockchainApiManagerModule,
  IBlockchainApiManager,
} from '@/domain/interfaces/blockchain-api.manager.interface';
import { IStakingRepository } from '@/domain/staking/staking.repository.interface';
import { StakingRepositoryModule } from '@/domain/staking/staking.repository.module';
import {
  ITokenRepository,
  TokenRepositoryModule,
} from '@/domain/tokens/token.repository.interface';
import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';
import {
  TransactionFinder,
  TransactionFinderModule,
} from '@/routes/transactions/helpers/transaction-finder.helper';
import { Inject, Injectable, Module } from '@nestjs/common';
import { parseAbi, toFunctionSelector } from 'viem';

@Injectable()
export class KilnPooledStakingHelper {
  private static readonly TOKEN_DEFAULT_DECIMALS = 18;

  constructor(
    private readonly transactionFinder: TransactionFinder,
    @Inject(IBlockchainApiManager)
    private readonly blockchainApiManager: IBlockchainApiManager,
    @Inject(ITokenRepository)
    private readonly tokenRepository: ITokenRepository,
    @Inject(IStakingRepository)
    private readonly stakingRepository: IStakingRepository,
  ) {}

  public async findStake(args: {
    chainId: string;
    to?: `0x${string}`;
    data: `0x${string}`;
  }): Promise<{
    to: `0x${string}`;
    data: `0x${string}`;
  } | null> {
    const selector = toFunctionSelector('function stake() external payable');
    const transaction = this.transactionFinder.findTransaction(
      (transaction) => transaction.data.startsWith(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 !== 'pooling' ||
      deployment?.chain === 'unknown'
    ) {
      return null;
    }

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

  public async findRequestExit(args: {
    chainId: string;
    to?: `0x${string}`;
    data: `0x${string}`;
  }): Promise<{
    to: `0x${string}`;
    data: `0x${string}`;
  } | null> {
    const selector = toFunctionSelector(
      'function requestExit(uint256 amount) external',
    );
    const transaction = this.transactionFinder.findTransaction(
      (transaction) => transaction.data.startsWith(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 !== 'pooling' ||
      deployment?.chain === 'unknown'
    ) {
      return null;
    }

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

  public async findMultiClaim(args: {
    chainId: string;
    to?: `0x${string}`;
    data: `0x${string}`;
  }): Promise<{
    to: `0x${string}`;
    data: `0x${string}`;
  } | null> {
    const selector = toFunctionSelector(
      'function multiClaim(address[] exitQueues, uint256[][] ticketIds, uint32[][] casksIds) external',
    );
    const transaction = this.transactionFinder.findTransaction(
      (transaction) => transaction.data.startsWith(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 !== 'pooling') {
      return null;
    }

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

  public async getRate(args: {
    chainId: string;
    pool: `0x${string}`;
  }): Promise<bigint> {
    const blockchainApi = await this.blockchainApiManager.getApi(args.chainId);
    // TODO: Should we cache this?
    return blockchainApi.readContract({
      abi: parseAbi(['function rate() external view returns (uint256)']),
      functionName: 'rate',
      address: args.pool,
    });
  }

  public async getPoolToken(args: {
    chainId: string;
    pool: `0x${string}`;
  }): Promise<TokenInfo> {
    const poolToken = await this.tokenRepository.getToken({
      chainId: args.chainId,
      address: args.pool,
    });

    return new TokenInfo({
      address: poolToken.address,
      decimals:
        poolToken.decimals ?? KilnPooledStakingHelper.TOKEN_DEFAULT_DECIMALS,
      logoUri: poolToken.logoUri,
      name: poolToken.name,
      symbol: poolToken.symbol,
      trusted: poolToken.trusted,
    });
  }
}

@Module({
  imports: [
    TransactionFinderModule,
    BlockchainApiManagerModule,
    TokenRepositoryModule,
    StakingRepositoryModule,
  ],
  providers: [KilnPooledStakingHelper],
  exports: [KilnPooledStakingHelper],
})
export class PooledStakingHelperModule {}

1	import {	16✔
2	BlockchainApiManagerModule,
3	IBlockchainApiManager,
4	} from '@/domain/interfaces/blockchain-api.manager.interface';
5	import { IStakingRepository } from '@/domain/staking/staking.repository.interface';	16✔
6	import { StakingRepositoryModule } from '@/domain/staking/staking.repository.module';	16✔
7	import {	16✔
8	ITokenRepository,
9	TokenRepositoryModule,
10	} from '@/domain/tokens/token.repository.interface';
11	import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';	16✔
12	import {	16✔
13	TransactionFinder,
14	TransactionFinderModule,
15	} from '@/routes/transactions/helpers/transaction-finder.helper';
16	import { Inject, Injectable, Module } from '@nestjs/common';	16✔
17	import { parseAbi, toFunctionSelector } from 'viem';	16✔
18
19	@Injectable()
20	export class KilnPooledStakingHelper {	16✔
21	private static readonly TOKEN_DEFAULT_DECIMALS = 18;	16✔
22
23	constructor(
24	private readonly transactionFinder: TransactionFinder,	16✔
25	@Inject(IBlockchainApiManager)
26	private readonly blockchainApiManager: IBlockchainApiManager,	16✔
27	@Inject(ITokenRepository)
28	private readonly tokenRepository: ITokenRepository,	16✔
29	@Inject(IStakingRepository)
30	private readonly stakingRepository: IStakingRepository,	16✔
31	) {}
32
33	public async findStake(args: {
34	chainId: string;
35	to?: `0x${string}`;
36	data: `0x${string}`;
37	}): Promise<{
38	to: `0x${string}`;
39	data: `0x${string}`;
40	} \| null> {
NEW 41	const selector = toFunctionSelector('function stake() external payable');	×
NEW 42	const transaction = this.transactionFinder.findTransaction(	×
NEW 43	(transaction) => transaction.data.startsWith(selector),	×
44	args,
45	);
46
NEW 47	if (!transaction?.to) {	×
NEW 48	return null;	×
49	}
50
NEW 51	const deployment = await this.stakingRepository	×
52	.getDeployment({
53	chainId: args.chainId,
54	address: transaction.to,
55	})
NEW 56	.catch(() => null);	×
57
NEW 58	if (	×
59	deployment?.product_type !== 'pooling' \|\|	×
60	deployment?.chain === 'unknown'	×
61	) {
NEW 62	return null;	×
63	}
64
NEW 65	return {	×
66	to: transaction.to,
67	data: transaction.data,
68	};
69	}
70
71	public async findRequestExit(args: {
72	chainId: string;
73	to?: `0x${string}`;
74	data: `0x${string}`;
75	}): Promise<{
76	to: `0x${string}`;
77	data: `0x${string}`;
78	} \| null> {
NEW 79	const selector = toFunctionSelector(	×
80	'function requestExit(uint256 amount) external',
81	);
NEW 82	const transaction = this.transactionFinder.findTransaction(	×
NEW 83	(transaction) => transaction.data.startsWith(selector),	×
84	args,
85	);
86
NEW 87	if (!transaction?.to) {	×
NEW 88	return null;	×
89	}
90
NEW 91	const deployment = await this.stakingRepository	×
92	.getDeployment({
93	chainId: args.chainId,
94	address: transaction.to,
95	})
NEW 96	.catch(() => null);	×
97
NEW 98	if (	×
99	deployment?.product_type !== 'pooling' \|\|	×
100	deployment?.chain === 'unknown'	×
101	) {
NEW 102	return null;	×
103	}
104
NEW 105	return {	×
106	to: transaction.to,
107	data: transaction.data,
108	};
109	}
110
111	public async findMultiClaim(args: {
112	chainId: string;
113	to?: `0x${string}`;
114	data: `0x${string}`;
115	}): Promise<{
116	to: `0x${string}`;
117	data: `0x${string}`;
118	} \| null> {
NEW 119	const selector = toFunctionSelector(	×
120	'function multiClaim(address[] exitQueues, uint256[][] ticketIds, uint32[][] casksIds) external',
121	);
NEW 122	const transaction = this.transactionFinder.findTransaction(	×
NEW 123	(transaction) => transaction.data.startsWith(selector),	×
124	args,
125	);
126
NEW 127	if (!transaction?.to) {	×
NEW 128	return null;	×
129	}
130
NEW 131	const deployment = await this.stakingRepository	×
132	.getDeployment({
133	chainId: args.chainId,
134	address: transaction.to,
135	})
NEW 136	.catch(() => null);	×
137
NEW 138	if (deployment?.product_type !== 'pooling') {	×
NEW 139	return null;	×
140	}
141
NEW 142	return {	×
143	to: transaction.to,
144	data: transaction.data,
145	};
146	}
147
148	public async getRate(args: {
149	chainId: string;
150	pool: `0x${string}`;
151	}): Promise<bigint> {
NEW 152	const blockchainApi = await this.blockchainApiManager.getApi(args.chainId);	×
153	// TODO: Should we cache this?
NEW 154	return blockchainApi.readContract({	×
155	abi: parseAbi(['function rate() external view returns (uint256)']),
156	functionName: 'rate',
157	address: args.pool,
158	});
159	}
160
161	public async getPoolToken(args: {
162	chainId: string;
163	pool: `0x${string}`;
164	}): Promise<TokenInfo> {
NEW 165	const poolToken = await this.tokenRepository.getToken({	×
166	chainId: args.chainId,
167	address: args.pool,
168	});
169
NEW 170	return new TokenInfo({	×
171	address: poolToken.address,
172	decimals:
173	poolToken.decimals ?? KilnPooledStakingHelper.TOKEN_DEFAULT_DECIMALS,	×
174	logoUri: poolToken.logoUri,
175	name: poolToken.name,
176	symbol: poolToken.symbol,
177	trusted: poolToken.trusted,
178	});
179	}
180	}
181
182	@Module({
183	imports: [
184	TransactionFinderModule,
185	BlockchainApiManagerModule,
186	TokenRepositoryModule,
187	StakingRepositoryModule,
188	],
189	providers: [KilnPooledStakingHelper],
190	exports: [KilnPooledStakingHelper],
191	})
192	export class PooledStakingHelperModule {}	16✔

safe-global / safe-client-gateway / 10456279889

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