9641495751

Committed 24 Jun 2024 07:41AM UTC coverage: 49.179% (-0.04%) from 49.216%

Build # 9641495751

Build Type

push

github

Committed by

iamacook

Commit Message

Add TWAP decoding to confirmation view

Run Details

415 of 2454 branches covered (16.91%)

Branch coverage included in aggregate %.

36 of 86 new or added lines in 7 files covered. (41.86%)

2 existing lines in 2 files now uncovered.

4105 of 6737 relevant lines covered (60.93%)

12.75 hits per line

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

32.0

/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,
      }),
    ]);

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

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

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	return {	×
112	order: { ...order, kind: order.kind },
113	buyToken,
114	sellToken,
115	};
116	}
117
118	/**
119	* Returns the URL to the explorer page of an order.
120	*
121	* @param order - The order to get the explorer URL for.
122	* @private
123	*/
124	getOrderExplorerUrl(order: Order): URL {
125	const url = new URL(this.swapsExplorerBaseUri);	×
126	url.pathname = `/orders/${order.uid}`;	×
127	return url;	×
128	}
129
130	/**
131	* Checks if the app associated with an order is allowed.
132	*
133	* @param order - the order to which we should verify the app data with
134	* @returns true if the app is allowed, false otherwise.
135	*/
136	isAppAllowed(order: Order): boolean {
137	if (!this.restrictApps) return true;	×
138	const appCode = order.fullAppData?.appCode;	×
139	return (	×
140	!!appCode && typeof appCode === 'string' && this.allowedApps.has(appCode)	×
141	);
142	}
143
144	private isSwapOrder(transaction: { data?: `0x${string}` }): boolean {
145	if (!transaction.data) return false;	×
146	return this.gpv2Decoder.helpers.isSetPreSignature(transaction.data);	×
147	}
148
149	/**
150	* Retrieves a token object based on the provided Ethereum chain ID and token address.
151	* If the specified address is the placeholder for the native currency of the chain,
152	* it fetches the chain's native currency details from the {@link IChainsRepository}.
153	* Otherwise, it fetches the token details from the {@link ITokenRepository}.
154	*
155	* @param args An object containing:
156	* - `chainId`: A string representing the ID of the blockchain chain.
157	* - `address`: A string representing the Ethereum address of the token, prefixed with '0x'.
158	* @returns {Promise<Token>} A promise that resolves to a Token object containing the details
159	* of either the native currency or the specified token with mandatory decimals.
160	* @throws {Error} Throws an error if the token data cannot be retrieved.
161	* @async
162	*/
163	public async getToken(args: {
164	chainId: string;
165	address: `0x${string}`;
166	}): Promise<Token & { decimals: NonNullable<Token['decimals']> }> {
167	// We perform lower case comparison because the provided address (3rd party service)
168	// might not be checksummed.
169	if (	×
170	args.address.toLowerCase() ===
171	SwapOrderHelper.NATIVE_CURRENCY_ADDRESS.toLowerCase()
172	) {
173	const { nativeCurrency } = await this.chainsRepository.getChain(	×
174	args.chainId,
175	);
176	return {	×
177	address: SwapOrderHelper.NATIVE_CURRENCY_ADDRESS,
178	decimals: nativeCurrency.decimals,
179	logoUri: nativeCurrency.logoUri,
180	name: nativeCurrency.name,
181	symbol: nativeCurrency.symbol,
182	type: TokenType.NativeToken,
183	trusted: true,
184	};
185	} else {
NEW 186	const token = await this.tokenRepository.getToken({	×
187	chainId: args.chainId,
188	address: args.address,
189	});
190
NEW 191	if (token.decimals === null) {	×
NEW 192	throw new Error('Invalid token decimals');	×
193	}
194
NEW 195	return { ...token, decimals: token.decimals };	×
196	}
197	}
198	}
199
200	function allowedAppsFactory(
201	configurationService: IConfigurationService,
202	): Set<string> {
203	const allowedApps =
204	configurationService.getOrThrow<string[]>('swaps.allowedApps');	16✔
205	return new Set(allowedApps);	16✔
206	}
207
208	@Module({
209	imports: [
210	ChainsRepositoryModule,
211	SwapsRepositoryModule,
212	TokenRepositoryModule,
213	],
214	providers: [
215	SwapOrderHelper,
216	MultiSendDecoder,
217	GPv2Decoder,
218	{
219	provide: 'SWAP_ALLOWED_APPS',
220	useFactory: allowedAppsFactory,
221	inject: [IConfigurationService],
222	},
223	],
224	exports: [SwapOrderHelper],
225	})
226	export class SwapOrderHelperModule {}	16✔

safe-global / safe-client-gateway / 9641495751

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