10456919491

Committed 19 Aug 2024 04:08PM UTC coverage: 46.094% (-0.7%) from 46.756%

Build # 10456919491

Build Type

Pull #1824

github

Committed by

iamacook

Commit Message

Merge branch 'main' into staking-confirmation-screens

Pull Request Pull Request #1824: Staking confirmation screens

Run Details

493 of 3121 branches covered (15.8%)

Branch coverage included in aggregate %.

250 of 524 new or added lines in 21 files covered. (47.71%)

3 existing lines in 1 file now uncovered.

4864 of 8501 relevant lines covered (57.22%)

12.38 hits per line

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

39.22

/src/routes/transactions/helpers/swap-order.helper.ts

import { Inject, Injectable, Module } from '@nestjs/common';
import {
  TransactionFinder,
  TransactionFinderModule,
} from '@/routes/transactions/helpers/transaction-finder.helper';
import { GPv2Decoder } from '@/domain/swaps/contracts/decoders/gp-v2-decoder.helper';
import {
  ITokenRepository,
  TokenRepositoryModule,
} from '@/domain/tokens/token.repository.interface';
import { ISwapsRepository } from '@/domain/swaps/swaps.repository';
import { Token, TokenType } from '@/domain/tokens/entities/token.entity';
import {
  KnownOrder,
  Order,
  OrderKind,
} from '@/domain/swaps/entities/order.entity';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { SwapsRepositoryModule } from '@/domain/swaps/swaps-repository.module';
import {
  ChainsRepositoryModule,
  IChainsRepository,
} from '@/domain/chains/chains.repository.interface';

@Injectable()
export class SwapOrderHelper {
  // This is the Native Currency address considered by CoW Swap
  // https://docs.cow.fi/cow-protocol/reference/sdks/cow-sdk/modules#buy_eth_address
  public static readonly NATIVE_CURRENCY_ADDRESS =
    '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';

  private readonly swapsExplorerBaseUri: string =
    this.configurationService.getOrThrow('swaps.explorerBaseUri');

  constructor(
    private readonly transactionFinder: TransactionFinder,
    private readonly gpv2Decoder: GPv2Decoder,
    @Inject(ITokenRepository)
    private readonly tokenRepository: ITokenRepository,
    @Inject(ISwapsRepository)
    private readonly swapsRepository: ISwapsRepository,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(IChainsRepository)
    private readonly chainsRepository: IChainsRepository,
  ) {}

  /**
   * Finds the swap order in the transaction data.
   * The swap order can be in the transaction data directly or in the data of a Multisend transaction.
   *
   * @param data - The transaction data
   * @private
   * @returns The swap order if found, otherwise null
   */
  public findSwapOrder(data: `0x${string}`): `0x${string}` | null {
    const transaction = this.transactionFinder.findTransaction(
      (transaction) =>
        this.gpv2Decoder.helpers.isSetPreSignature(transaction.data),
      { data },
    );
    return transaction?.data ?? null;
  }

  /**
   * Retrieves detailed information about a specific order and its associated tokens
   *
   * @param {Object} args - The arguments required to fetch the order.
   * @param {string} args.chainId - The network chain ID.
   * @param {string} args.orderUid - The unique identifier of the order, prefixed with '0x'.
   * @returns {Promise} A promise that resolves to an object containing the order and token details.
   *
   * The returned object represents the order.
   *
   * @throws {Error} Throws an error if the order `kind` is 'unknown'.
   * @throws {Error} Throws an error if either the sellToken or buyToken object has null decimals.
   */
  async getOrder(args: {
    chainId: string;
    orderUid: `0x${string}`;
  }): Promise<KnownOrder> {
    const order = await this.swapsRepository.getOrder(
      args.chainId,
      args.orderUid,
    );

    if (order.kind === OrderKind.Unknown) throw new Error('Unknown order kind');

    return {
      ...order,
      kind: order.kind,
    };
  }

  /**
   * Returns the URL to the explorer page of an order.
   *
   * @param order - The order to get the explorer URL for.
   * @private
   */
  getOrderExplorerUrl(order: Order): URL {
    const url = new URL(this.swapsExplorerBaseUri);
    url.pathname = `/orders/${order.uid}`;
    return url;
  }

  /**
   * Retrieves a token object based on the provided Ethereum chain ID and token address.
   * If the specified address is the placeholder for the native currency of the chain,
   * it fetches the chain's native currency details from the {@link IChainsRepository}.
   * Otherwise, it fetches the token details from the {@link ITokenRepository}.
   *
   * @param args An object containing:
   *   - `chainId`: A string representing the ID of the blockchain chain.
   *   - `address`: A string representing the Ethereum address of the token, prefixed with '0x'.
   * @returns {Promise<Token>} A promise that resolves to a Token object containing the details
   * of either the native currency or the specified token with mandatory decimals.
   * @throws {Error} Throws an error if the token data cannot be retrieved.
   * @async
   */
  public async getToken(args: {
    chainId: string;
    address: `0x${string}`;
  }): Promise<Token & { decimals: NonNullable<Token['decimals']> }> {
    // We perform lower case comparison because the provided address (3rd party service)
    // might not be checksummed.
    if (
      args.address.toLowerCase() ===
      SwapOrderHelper.NATIVE_CURRENCY_ADDRESS.toLowerCase()
    ) {
      const { nativeCurrency } = await this.chainsRepository.getChain(
        args.chainId,
      );
      return {
        address: SwapOrderHelper.NATIVE_CURRENCY_ADDRESS,
        decimals: nativeCurrency.decimals,
        logoUri: nativeCurrency.logoUri,
        name: nativeCurrency.name,
        symbol: nativeCurrency.symbol,
        type: TokenType.NativeToken,
        trusted: true,
      };
    } else {
      const token = await this.tokenRepository.getToken({
        chainId: args.chainId,
        address: args.address,
      });

      if (token.decimals === null) {
        throw new Error('Invalid token decimals');
      }

      return { ...token, decimals: token.decimals };
    }
  }
}

@Module({
  imports: [
    ChainsRepositoryModule,
    SwapsRepositoryModule,
    TokenRepositoryModule,
    TransactionFinderModule,
  ],
  providers: [SwapOrderHelper, GPv2Decoder],
  exports: [SwapOrderHelper],
})
export class SwapOrderHelperModule {}

1	import { Inject, Injectable, Module } from '@nestjs/common';	16✔
2	import {	16✔
3	TransactionFinder,
4	TransactionFinderModule,
5	} from '@/routes/transactions/helpers/transaction-finder.helper';
6	import { GPv2Decoder } from '@/domain/swaps/contracts/decoders/gp-v2-decoder.helper';	16✔
7	import {	16✔
8	ITokenRepository,
9	TokenRepositoryModule,
10	} from '@/domain/tokens/token.repository.interface';
11	import { ISwapsRepository } from '@/domain/swaps/swaps.repository';	16✔
12	import { Token, TokenType } from '@/domain/tokens/entities/token.entity';	16✔
13	import {	16✔
14	KnownOrder,
15	Order,
16	OrderKind,
17	} from '@/domain/swaps/entities/order.entity';
18	import { IConfigurationService } from '@/config/configuration.service.interface';	16✔
19	import { SwapsRepositoryModule } from '@/domain/swaps/swaps-repository.module';	16✔
20	import {	16✔
21	ChainsRepositoryModule,
22	IChainsRepository,
23	} from '@/domain/chains/chains.repository.interface';
24
25	@Injectable()
26	export class SwapOrderHelper {	16✔
27	// This is the Native Currency address considered by CoW Swap
28	// https://docs.cow.fi/cow-protocol/reference/sdks/cow-sdk/modules#buy_eth_address
29	public static readonly NATIVE_CURRENCY_ADDRESS =	16✔
30	'0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
31
32	private readonly swapsExplorerBaseUri: string =	16✔
33	this.configurationService.getOrThrow('swaps.explorerBaseUri');
34
35	constructor(
36	private readonly transactionFinder: TransactionFinder,	16✔
37	private readonly gpv2Decoder: GPv2Decoder,	16✔
38	@Inject(ITokenRepository)
39	private readonly tokenRepository: ITokenRepository,	16✔
40	@Inject(ISwapsRepository)
41	private readonly swapsRepository: ISwapsRepository,	16✔
42	@Inject(IConfigurationService)
43	private readonly configurationService: IConfigurationService,	16✔
44	@Inject(IChainsRepository)
45	private readonly chainsRepository: IChainsRepository,	16✔
46	) {}
47
48	/**
49	* Finds the swap order in the transaction data.
50	* The swap order can be in the transaction data directly or in the data of a Multisend transaction.
51	*
52	* @param data - The transaction data
53	* @private
54	* @returns The swap order if found, otherwise null
55	*/
56	public findSwapOrder(data: `0x${string}`): `0x${string}` \| null {
NEW 57	const transaction = this.transactionFinder.findTransaction(	×
58	(transaction) =>
59	this.gpv2Decoder.helpers.isSetPreSignature(transaction.data),	×
60	{ data },
61	);
NEW 62	return transaction?.data ?? null;	×
63	}
64
65	/**
66	* Retrieves detailed information about a specific order and its associated tokens
67	*
68	* @param {Object} args - The arguments required to fetch the order.
69	* @param {string} args.chainId - The network chain ID.
70	* @param {string} args.orderUid - The unique identifier of the order, prefixed with '0x'.
71	* @returns {Promise} A promise that resolves to an object containing the order and token details.
72	*
73	* The returned object represents the order.
74	*
75	* @throws {Error} Throws an error if the order `kind` is 'unknown'.
76	* @throws {Error} Throws an error if either the sellToken or buyToken object has null decimals.
77	*/
78	async getOrder(args: {
79	chainId: string;
80	orderUid: `0x${string}`;
81	}): Promise<KnownOrder> {
82	const order = await this.swapsRepository.getOrder(	×
83	args.chainId,
84	args.orderUid,
85	);
86
87	if (order.kind === OrderKind.Unknown) throw new Error('Unknown order kind');	×
88
89	return {	×
90	...order,
91	kind: order.kind,
92	};
93	}
94
95	/**
96	* Returns the URL to the explorer page of an order.
97	*
98	* @param order - The order to get the explorer URL for.
99	* @private
100	*/
101	getOrderExplorerUrl(order: Order): URL {
102	const url = new URL(this.swapsExplorerBaseUri);	×
103	url.pathname = `/orders/${order.uid}`;	×
104	return url;	×
105	}
106
107	/**
108	* Retrieves a token object based on the provided Ethereum chain ID and token address.
109	* If the specified address is the placeholder for the native currency of the chain,
110	* it fetches the chain's native currency details from the {@link IChainsRepository}.
111	* Otherwise, it fetches the token details from the {@link ITokenRepository}.
112	*
113	* @param args An object containing:
114	* - `chainId`: A string representing the ID of the blockchain chain.
115	* - `address`: A string representing the Ethereum address of the token, prefixed with '0x'.
116	* @returns {Promise<Token>} A promise that resolves to a Token object containing the details
117	* of either the native currency or the specified token with mandatory decimals.
118	* @throws {Error} Throws an error if the token data cannot be retrieved.
119	* @async
120	*/
121	public async getToken(args: {
122	chainId: string;
123	address: `0x${string}`;
124	}): Promise<Token & { decimals: NonNullable<Token['decimals']> }> {
125	// We perform lower case comparison because the provided address (3rd party service)
126	// might not be checksummed.
127	if (	×
128	args.address.toLowerCase() ===
129	SwapOrderHelper.NATIVE_CURRENCY_ADDRESS.toLowerCase()
130	) {
131	const { nativeCurrency } = await this.chainsRepository.getChain(	×
132	args.chainId,
133	);
134	return {	×
135	address: SwapOrderHelper.NATIVE_CURRENCY_ADDRESS,
136	decimals: nativeCurrency.decimals,
137	logoUri: nativeCurrency.logoUri,
138	name: nativeCurrency.name,
139	symbol: nativeCurrency.symbol,
140	type: TokenType.NativeToken,
141	trusted: true,
142	};
143	} else {
144	const token = await this.tokenRepository.getToken({	×
145	chainId: args.chainId,
146	address: args.address,
147	});
148
149	if (token.decimals === null) {	×
150	throw new Error('Invalid token decimals');	×
151	}
152
153	return { ...token, decimals: token.decimals };	×
154	}
155	}
156	}
157
158	@Module({
159	imports: [
160	ChainsRepositoryModule,
161	SwapsRepositoryModule,
162	TokenRepositoryModule,
163	TransactionFinderModule,
164	],
165	providers: [SwapOrderHelper, GPv2Decoder],
166	exports: [SwapOrderHelper],
167	})
168	export class SwapOrderHelperModule {}	16✔

safe-global / safe-client-gateway / 10456919491

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