9644961387

Committed 24 Jun 2024 12:03PM UTC coverage: 48.707% (-0.03%) from 48.734%

Build # 9644961387

Build Type

push

github

Committed by

web-flow

Commit Message

Map TWAP orders in the queue (#1683)

Removes the requirement of an `executionDate` to map TWAP orders, meaning queued orders are now mapped:

- Decouple fetching of buy/sell token with order, fetching the later separately
- Don't fetch orders if the transaction is not executed, mapping "empty" values if no orders were fetched
- Add/update the test coverage accordingly

Run Details

415 of 2485 branches covered (16.7%)

Branch coverage included in aggregate %.

0 of 13 new or added lines in 4 files covered. (0.0%)

4 existing lines in 4 files now uncovered.

4107 of 6799 relevant lines covered (60.41%)

13.24 hits per line

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

27.27

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

  // TODO: Refactor findSwapOrder and findTwapSwapOrder to avoid code duplication

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

  /**
   * Finds the `settle` transaction in provided data.
   * The call can either be direct or parsed from within a MultiSend batch.
   *
   * @param data - transaction data to search for the `settle` transaction in
   * @returns transaction data of `settle` transaction if found, otherwise null
   */
  public findTwapSwapOrder(data: `0x${string}`): `0x${string}` | null {
    if (this.gpv2Decoder.helpers.isSettle(data)) {
      return data;
    }

    if (this.multiSendDecoder.helpers.isMultiSend(data)) {
      const transactions = this.multiSendDecoder.mapMultiSendTransactions(data);
      for (const transaction of transactions) {
        if (this.gpv2Decoder.helpers.isSettle(transaction.data)) {
          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 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<Order & { kind: Exclude<Order['kind'], 'unknown'> }> {
    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;
  }

  /**
   * 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	// TODO: Refactor findSwapOrder and findTwapSwapOrder to avoid code duplication
46
47	/**
48	* Finds the swap order in the transaction data.
49	* The swap order can be in the transaction data directly or in the data of a Multisend transaction.
50	*
51	* @param data - The transaction data
52	* @private
53	* @returns The swap order if found, otherwise null
54	*/
55	public findSwapOrder(data: `0x${string}`): `0x${string}` \| null {
56	// The swap order can be in the transaction data directly
57	if (this.isSwapOrder({ data })) {	×
58	return data;	×
59	}
60	// or in the data of a multisend transaction
61	if (this.multiSendDecoder.helpers.isMultiSend(data)) {	×
62	const transactions = this.multiSendDecoder.mapMultiSendTransactions(data);	×
63	// TODO If we can build a sorted hash map of the transactions, we can avoid iterating all of them
64	// as we know the pattern of a Swap Order.
65	for (const transaction of transactions) {	×
66	if (this.isSwapOrder(transaction)) {	×
67	return transaction.data;	×
68	}
69	}
70	}
71	return null;	×
72	}
73
74	/**
75	* Finds the `settle` transaction in provided data.
76	* The call can either be direct or parsed from within a MultiSend batch.
77	*
78	* @param data - transaction data to search for the `settle` transaction in
79	* @returns transaction data of `settle` transaction if found, otherwise null
80	*/
81	public findTwapSwapOrder(data: `0x${string}`): `0x${string}` \| null {
82	if (this.gpv2Decoder.helpers.isSettle(data)) {	×
83	return data;	×
84	}
85
86	if (this.multiSendDecoder.helpers.isMultiSend(data)) {	×
87	const transactions = this.multiSendDecoder.mapMultiSendTransactions(data);	×
88	for (const transaction of transactions) {	×
89	if (this.gpv2Decoder.helpers.isSettle(transaction.data)) {	×
90	return transaction.data;	×
91	}
92	}
93	}
94
95	return null;	×
96	}
97
98	/**
99	* Retrieves detailed information about a specific order and its associated tokens
100	*
101	* @param {Object} args - The arguments required to fetch the order.
102	* @param {string} args.chainId - The network chain ID.
103	* @param {string} args.orderUid - The unique identifier of the order, prefixed with '0x'.
104	* @returns {Promise} A promise that resolves to an object containing the order and token details.
105	*
106	* The returned object represents the order.
107	*
108	* @throws {Error} Throws an error if the order `kind` is 'unknown'.
109	* @throws {Error} Throws an error if either the sellToken or buyToken object has null decimals.
110	*/
111	async getOrder(args: {
112	chainId: string;
113	orderUid: `0x${string}`;
114	}): Promise<Order & { kind: Exclude<Order['kind'], 'unknown'> }> {
UNCOV 115	const order = await this.swapsRepository.getOrder(	×
116	args.chainId,
117	args.orderUid,
118	);
119
120	if (order.kind === OrderKind.Unknown) throw new Error('Unknown order kind');	×
121
122	return {	×
123	...order,
124	kind: order.kind,
125	};
126	}
127
128	/**
129	* Returns the URL to the explorer page of an order.
130	*
131	* @param order - The order to get the explorer URL for.
132	* @private
133	*/
134	getOrderExplorerUrl(order: Order): URL {
135	const url = new URL(this.swapsExplorerBaseUri);	×
136	url.pathname = `/orders/${order.uid}`;	×
137	return url;	×
138	}
139
140	/**
141	* Checks if the app associated with an order is allowed.
142	*
143	* @param order - the order to which we should verify the app data with
144	* @returns true if the app is allowed, false otherwise.
145	*/
146	isAppAllowed(order: Order): boolean {
147	if (!this.restrictApps) return true;	×
148	const appCode = order.fullAppData?.appCode;	×
149	return (	×
150	!!appCode && typeof appCode === 'string' && this.allowedApps.has(appCode)	×
151	);
152	}
153
154	private isSwapOrder(transaction: { data?: `0x${string}` }): boolean {
155	if (!transaction.data) return false;	×
156	return this.gpv2Decoder.helpers.isSetPreSignature(transaction.data);	×
157	}
158
159	/**
160	* Retrieves a token object based on the provided Ethereum chain ID and token address.
161	* If the specified address is the placeholder for the native currency of the chain,
162	* it fetches the chain's native currency details from the {@link IChainsRepository}.
163	* Otherwise, it fetches the token details from the {@link ITokenRepository}.
164	*
165	* @param args An object containing:
166	* - `chainId`: A string representing the ID of the blockchain chain.
167	* - `address`: A string representing the Ethereum address of the token, prefixed with '0x'.
168	* @returns {Promise<Token>} A promise that resolves to a Token object containing the details
169	* of either the native currency or the specified token with mandatory decimals.
170	* @throws {Error} Throws an error if the token data cannot be retrieved.
171	* @async
172	*/
173	public async getToken(args: {
174	chainId: string;
175	address: `0x${string}`;
176	}): Promise<Token & { decimals: NonNullable<Token['decimals']> }> {
177	// We perform lower case comparison because the provided address (3rd party service)
178	// might not be checksummed.
179	if (	×
180	args.address.toLowerCase() ===
181	SwapOrderHelper.NATIVE_CURRENCY_ADDRESS.toLowerCase()
182	) {
183	const { nativeCurrency } = await this.chainsRepository.getChain(	×
184	args.chainId,
185	);
186	return {	×
187	address: SwapOrderHelper.NATIVE_CURRENCY_ADDRESS,
188	decimals: nativeCurrency.decimals,
189	logoUri: nativeCurrency.logoUri,
190	name: nativeCurrency.name,
191	symbol: nativeCurrency.symbol,
192	type: TokenType.NativeToken,
193	trusted: true,
194	};
195	} else {
196	const token = await this.tokenRepository.getToken({	×
197	chainId: args.chainId,
198	address: args.address,
199	});
200
201	if (token.decimals === null) {	×
202	throw new Error('Invalid token decimals');	×
203	}
204
205	return { ...token, decimals: token.decimals };	×
206	}
207	}
208	}
209
210	function allowedAppsFactory(
211	configurationService: IConfigurationService,
212	): Set<string> {
213	const allowedApps =
214	configurationService.getOrThrow<string[]>('swaps.allowedApps');	16✔
215	return new Set(allowedApps);	16✔
216	}
217
218	@Module({
219	imports: [
220	ChainsRepositoryModule,
221	SwapsRepositoryModule,
222	TokenRepositoryModule,
223	],
224	providers: [
225	SwapOrderHelper,
226	MultiSendDecoder,
227	GPv2Decoder,
228	{
229	provide: 'SWAP_ALLOWED_APPS',
230	useFactory: allowedAppsFactory,
231	inject: [IConfigurationService],
232	},
233	],
234	exports: [SwapOrderHelper],
235	})
236	export class SwapOrderHelperModule {}	16✔

safe-global / safe-client-gateway / 9644961387

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