9579511885

Committed 19 Jun 2024 09:23AM UTC coverage: 49.042% (-0.2%) from 49.274%

Build # 9579511885

Build Type

Pull #1673

github

Committed by

iamacook

Commit Message

Remove unnecessary mock

Pull Request Pull Request #1673: Add method to decode order from `settlement`

Run Details

410 of 2443 branches covered (16.78%)

Branch coverage included in aggregate %.

6 of 39 new or added lines in 1 file covered. (15.38%)

4 existing lines in 1 file now uncovered.

4067 of 6686 relevant lines covered (60.83%)

13.37 hits per line

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

32.43

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

import { Inject, Injectable, Module } from '@nestjs/common';
import { MultiSendDecoder } from '@/domain/contracts/decoders/multi-send-decoder.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 { 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
  private static readonly NATIVE_CURRENCY_ADDRESS =
    '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';

  private readonly restrictApps: boolean =
    this.configurationService.getOrThrow('swaps.restrictApps');

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

  constructor(
    private readonly multiSendDecoder: MultiSendDecoder,
    private readonly gpv2Decoder: GPv2Decoder,
    @Inject(ITokenRepository)
    private readonly tokenRepository: ITokenRepository,
    @Inject(ISwapsRepository)
    private readonly swapsRepository: ISwapsRepository,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject('SWAP_ALLOWED_APPS') private readonly allowedApps: Set<string>,
    @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 {
    // The swap order can be in the transaction data directly
    if (this.isSwapOrder({ data })) {
      return data;
    }
    // or in the data of a multisend transaction
    if (this.multiSendDecoder.helpers.isMultiSend(data)) {
      const transactions = this.multiSendDecoder.mapMultiSendTransactions(data);
      // TODO If we can build a sorted hash map of the transactions, we can avoid iterating all of them
      //  as we know the pattern of a Swap Order.
      for (const transaction of transactions) {
        if (this.isSwapOrder(transaction)) {
          return transaction.data;
        }
      }
    }
    return 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 includes:
   * - `order`: An object representing the order.
   * - `sellToken`: The Token object with a mandatory `decimals` property
   * - `buyToken`: Similar to `sellToken`, for the token being purchased in 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<{
    order: Order & { kind: Exclude<Order['kind'], 'unknown'> };
    sellToken: Token & { decimals: number };
    buyToken: Token & { decimals: number };
  }> {
    const order = await this.swapsRepository.getOrder(
      args.chainId,
      args.orderUid,
    );

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

    const [buyToken, sellToken] = await Promise.all([
      this.getToken({
        chainId: args.chainId,
        address: order.buyToken,
      }),
      this.getToken({
        chainId: args.chainId,
        address: order.sellToken,
      }),
    ]);

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

    return {
      order: { ...order, kind: order.kind },
      buyToken: { ...buyToken, decimals: buyToken.decimals },
      sellToken: { ...sellToken, decimals: sellToken.decimals },
    };
  }

  /**
   * 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;
  }

  /**
   * Checks if the app associated with an order is allowed.
   *
   * @param order - the order to which we should verify the app data with
   * @returns true if the app is allowed, false otherwise.
   */
  isAppAllowed(order: Order): boolean {
    if (!this.restrictApps) return true;
    const appCode = order.fullAppData?.appCode;
    return (
      !!appCode && typeof appCode === 'string' && this.allowedApps.has(appCode)
    );
  }

  private isSwapOrder(transaction: { data?: `0x${string}` }): boolean {
    if (!transaction.data) return false;
    return this.gpv2Decoder.helpers.isSetPreSignature(transaction.data);
  }

  /**
   * 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.
   * @throws {Error} Throws an error if the token data cannot be retrieved.
   * @private
   * @async
   */
  private async getToken(args: {
    chainId: string;
    address: `0x${string}`;
  }): Promise<Token> {
    // 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 {
      return this.tokenRepository.getToken({
        chainId: args.chainId,
        address: args.address,
      });
    }
  }
}

function allowedAppsFactory(
  configurationService: IConfigurationService,
): Set<string> {
  const allowedApps =
    configurationService.getOrThrow<string[]>('swaps.allowedApps');
  return new Set(allowedApps);
}

@Module({
  imports: [
    ChainsRepositoryModule,
    SwapsRepositoryModule,
    TokenRepositoryModule,
  ],
  providers: [
    SwapOrderHelper,
    MultiSendDecoder,
    GPv2Decoder,
    {
      provide: 'SWAP_ALLOWED_APPS',
      useFactory: allowedAppsFactory,
      inject: [IConfigurationService],
    },
  ],
  exports: [SwapOrderHelper],
})
export class SwapOrderHelperModule {}

1	import { Inject, Injectable, Module } from '@nestjs/common';	16✔
2	import { MultiSendDecoder } from '@/domain/contracts/decoders/multi-send-decoder.helper';	16✔
3	import { GPv2Decoder } from '@/domain/swaps/contracts/decoders/gp-v2-decoder.helper';	16✔
4	import {	16✔
5	ITokenRepository,
6	TokenRepositoryModule,
7	} from '@/domain/tokens/token.repository.interface';
8	import { ISwapsRepository } from '@/domain/swaps/swaps.repository';	16✔
9	import { Token, TokenType } from '@/domain/tokens/entities/token.entity';	16✔
10	import { Order, OrderKind } from '@/domain/swaps/entities/order.entity';	16✔
11	import { IConfigurationService } from '@/config/configuration.service.interface';	16✔
12	import { SwapsRepositoryModule } from '@/domain/swaps/swaps-repository.module';	16✔
13	import {	16✔
14	ChainsRepositoryModule,
15	IChainsRepository,
16	} from '@/domain/chains/chains.repository.interface';
17
18	@Injectable()
19	export class SwapOrderHelper {	16✔
20	// This is the Native Currency address considered by CoW Swap
21	// https://docs.cow.fi/cow-protocol/reference/sdks/cow-sdk/modules#buy_eth_address
22	private static readonly NATIVE_CURRENCY_ADDRESS =	16✔
23	'0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE';
24
25	private readonly restrictApps: boolean =	16✔
26	this.configurationService.getOrThrow('swaps.restrictApps');
27
28	private readonly swapsExplorerBaseUri: string =	16✔
29	this.configurationService.getOrThrow('swaps.explorerBaseUri');
30
31	constructor(
32	private readonly multiSendDecoder: MultiSendDecoder,	16✔
33	private readonly gpv2Decoder: GPv2Decoder,	16✔
34	@Inject(ITokenRepository)
35	private readonly tokenRepository: ITokenRepository,	16✔
36	@Inject(ISwapsRepository)
37	private readonly swapsRepository: ISwapsRepository,	16✔
38	@Inject(IConfigurationService)
39	private readonly configurationService: IConfigurationService,	16✔
40	@Inject('SWAP_ALLOWED_APPS') private readonly allowedApps: Set<string>,	16✔
41	@Inject(IChainsRepository)
42	private readonly chainsRepository: IChainsRepository,	16✔
43	) {}
44
45	/**
46	* Finds the swap order in the transaction data.
47	* The swap order can be in the transaction data directly or in the data of a Multisend transaction.
48	*
49	* @param data - The transaction data
50	* @private
51	* @returns The swap order if found, otherwise null
52	*/
53	public findSwapOrder(data: `0x${string}`): `0x${string}` \| null {
54	// The swap order can be in the transaction data directly
55	if (this.isSwapOrder({ data })) {	×
56	return data;	×
57	}
58	// or in the data of a multisend transaction
59	if (this.multiSendDecoder.helpers.isMultiSend(data)) {	×
60	const transactions = this.multiSendDecoder.mapMultiSendTransactions(data);	×
61	// TODO If we can build a sorted hash map of the transactions, we can avoid iterating all of them
62	// as we know the pattern of a Swap Order.
63	for (const transaction of transactions) {	×
64	if (this.isSwapOrder(transaction)) {	×
65	return transaction.data;	×
66	}
67	}
68	}
69	return null;	×
70	}
71
72	/**
73	* Retrieves detailed information about a specific order and its associated tokens
74	*
75	* @param {Object} args - The arguments required to fetch the order.
76	* @param {string} args.chainId - The network chain ID.
77	* @param {string} args.orderUid - The unique identifier of the order, prefixed with '0x'.
78	* @returns {Promise} A promise that resolves to an object containing the order and token details.
79	*
80	* The returned object includes:
81	* - `order`: An object representing the order.
82	* - `sellToken`: The Token object with a mandatory `decimals` property
83	* - `buyToken`: Similar to `sellToken`, for the token being purchased in the order.
84	*
85	* @throws {Error} Throws an error if the order `kind` is 'unknown'.
86	* @throws {Error} Throws an error if either the sellToken or buyToken object has null decimals.
87	*/
88	async getOrder(args: { chainId: string; orderUid: `0x${string}` }): Promise<{
89	order: Order & { kind: Exclude<Order['kind'], 'unknown'> };
90	sellToken: Token & { decimals: number };
91	buyToken: Token & { decimals: number };
92	}> {
93	const order = await this.swapsRepository.getOrder(	×
94	args.chainId,
95	args.orderUid,
96	);
97
98	if (order.kind === OrderKind.Unknown) throw new Error('Unknown order kind');	×
99
100	const [buyToken, sellToken] = await Promise.all([	×
101	this.getToken({
102	chainId: args.chainId,
103	address: order.buyToken,
104	}),
105	this.getToken({
106	chainId: args.chainId,
107	address: order.sellToken,
108	}),
109	]);
110
111	if (buyToken.decimals === null \|\| sellToken.decimals === null) {	×
112	throw new Error('Invalid token decimals');	×
113	}
114
115	return {	×
116	order: { ...order, kind: order.kind },
117	buyToken: { ...buyToken, decimals: buyToken.decimals },
118	sellToken: { ...sellToken, decimals: sellToken.decimals },
119	};
120	}
121
122	/**
123	* Returns the URL to the explorer page of an order.
124	*
125	* @param order - The order to get the explorer URL for.
126	* @private
127	*/
128	getOrderExplorerUrl(order: Order): URL {
129	const url = new URL(this.swapsExplorerBaseUri);	×
130	url.pathname = `/orders/${order.uid}`;	×
131	return url;	×
132	}
133
134	/**
135	* Checks if the app associated with an order is allowed.
136	*
137	* @param order - the order to which we should verify the app data with
138	* @returns true if the app is allowed, false otherwise.
139	*/
140	isAppAllowed(order: Order): boolean {
141	if (!this.restrictApps) return true;	×
142	const appCode = order.fullAppData?.appCode;	×
143	return (	×
144	!!appCode && typeof appCode === 'string' && this.allowedApps.has(appCode)	×
145	);
146	}
147
148	private isSwapOrder(transaction: { data?: `0x${string}` }): boolean {
149	if (!transaction.data) return false;	×
150	return this.gpv2Decoder.helpers.isSetPreSignature(transaction.data);	×
151	}
152
153	/**
154	* Retrieves a token object based on the provided Ethereum chain ID and token address.
155	* If the specified address is the placeholder for the native currency of the chain,
156	* it fetches the chain's native currency details from the {@link IChainsRepository}.
157	* Otherwise, it fetches the token details from the {@link ITokenRepository}.
158	*
159	* @param args An object containing:
160	* - `chainId`: A string representing the ID of the blockchain chain.
161	* - `address`: A string representing the Ethereum address of the token, prefixed with '0x'.
162	* @returns {Promise<Token>} A promise that resolves to a Token object containing the details
163	* of either the native currency or the specified token.
164	* @throws {Error} Throws an error if the token data cannot be retrieved.
165	* @private
166	* @async
167	*/
168	private async getToken(args: {
169	chainId: string;
170	address: `0x${string}`;
171	}): Promise<Token> {
172	// We perform lower case comparison because the provided address (3rd party service)
173	// might not be checksummed.
UNCOV 174	if (	×
175	args.address.toLowerCase() ===
176	SwapOrderHelper.NATIVE_CURRENCY_ADDRESS.toLowerCase()
177	) {
UNCOV 178	const { nativeCurrency } = await this.chainsRepository.getChain(	×
179	args.chainId,
180	);
UNCOV 181	return {	×
182	address: SwapOrderHelper.NATIVE_CURRENCY_ADDRESS,
183	decimals: nativeCurrency.decimals,
184	logoUri: nativeCurrency.logoUri,
185	name: nativeCurrency.name,
186	symbol: nativeCurrency.symbol,
187	type: TokenType.NativeToken,
188	trusted: true,
189	};
190	} else {
UNCOV 191	return this.tokenRepository.getToken({	×
192	chainId: args.chainId,
193	address: args.address,
194	});
195	}
196	}
197	}
198
199	function allowedAppsFactory(
200	configurationService: IConfigurationService,
201	): Set<string> {
202	const allowedApps =
203	configurationService.getOrThrow<string[]>('swaps.allowedApps');	16✔
204	return new Set(allowedApps);	16✔
205	}
206
207	@Module({
208	imports: [
209	ChainsRepositoryModule,
210	SwapsRepositoryModule,
211	TokenRepositoryModule,
212	],
213	providers: [
214	SwapOrderHelper,
215	MultiSendDecoder,
216	GPv2Decoder,
217	{
218	provide: 'SWAP_ALLOWED_APPS',
219	useFactory: allowedAppsFactory,
220	inject: [IConfigurationService],
221	},
222	],
223	exports: [SwapOrderHelper],
224	})
225	export class SwapOrderHelperModule {}	16✔

safe-global / safe-client-gateway / 9579511885

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