8781721739

Committed 22 Apr 2024 09:26AM UTC coverage: 92.262% (-0.7%) from 92.966%

Build # 8781721739

Build Type

push

github

Committed by

fmrsabino

Commit Message

Wip

Run Details

1925 of 2339 branches covered (82.3%)

Branch coverage included in aggregate %.

80 of 126 new or added lines in 10 files covered. (63.49%)

4 existing lines in 1 file now uncovered.

6898 of 7224 relevant lines covered (95.49%)

311.49 hits per line

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

63.04

/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 { SetPreSignatureDecoder } from '@/domain/swaps/contracts/decoders/set-pre-signature-decoder.helper';
import {
  ITokenRepository,
  TokenRepositoryModule,
} from '@/domain/tokens/token.repository.interface';
import {
  ISwapsRepository,
  SwapsRepository,
} from '@/domain/swaps/swaps.repository';
import { Token } from '@/domain/tokens/entities/token.entity';
import { Order } from '@/domain/swaps/entities/order.entity';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { SwapsRepositoryModule } from '@/domain/swaps/swaps-repository.module';

@Injectable()
export class SwapOrderHelper {
  private readonly swapsExplorerBaseUri: string =
    this.configurationService.getOrThrow('swaps.explorerBaseUri');

  constructor(
    private readonly multiSendDecoder: MultiSendDecoder,
    private readonly setPreSignatureDecoder: SetPreSignatureDecoder,
    @Inject(ITokenRepository)
    private readonly tokenRepository: ITokenRepository,
    @Inject(ISwapsRepository) private readonly swapsRepository: SwapsRepository,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
  ) {}

  /**
   * 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: Omit<Order, 'kind'> & { 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 === 'unknown') throw new Error('Unknown order kind');

    const [buyToken, sellToken] = await Promise.all([
      this.tokenRepository.getToken({
        chainId: args.chainId,
        address: order.buyToken,
      }),
      this.tokenRepository.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;
  }

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

@Module({
  imports: [SwapsRepositoryModule, TokenRepositoryModule],
  providers: [SwapOrderHelper, MultiSendDecoder, SetPreSignatureDecoder],
  exports: [SwapOrderHelper],
})
export class SwapOrderHelperModule {}

1	import { Inject, Injectable, Module } from '@nestjs/common';	102✔
2	import { MultiSendDecoder } from '@/domain/contracts/decoders/multi-send-decoder.helper';	102✔
3	import { SetPreSignatureDecoder } from '@/domain/swaps/contracts/decoders/set-pre-signature-decoder.helper';	102✔
4	import {	102✔
5	ITokenRepository,
6	TokenRepositoryModule,
7	} from '@/domain/tokens/token.repository.interface';
8	import {	102✔
9	ISwapsRepository,
10	SwapsRepository,
11	} from '@/domain/swaps/swaps.repository';
12	import { Token } from '@/domain/tokens/entities/token.entity';
13	import { Order } from '@/domain/swaps/entities/order.entity';
14	import { IConfigurationService } from '@/config/configuration.service.interface';	102✔
15	import { SwapsRepositoryModule } from '@/domain/swaps/swaps-repository.module';	102✔
16
17	@Injectable()
18	export class SwapOrderHelper {	102✔
19	private readonly swapsExplorerBaseUri: string =	1,240✔
20	this.configurationService.getOrThrow('swaps.explorerBaseUri');
21
22	constructor(
23	private readonly multiSendDecoder: MultiSendDecoder,	1,240✔
24	private readonly setPreSignatureDecoder: SetPreSignatureDecoder,	1,240✔
25	@Inject(ITokenRepository)
26	private readonly tokenRepository: ITokenRepository,	1,240✔
27	@Inject(ISwapsRepository) private readonly swapsRepository: SwapsRepository,	1,240✔
28	@Inject(IConfigurationService)
29	private readonly configurationService: IConfigurationService,	1,240✔
30	) {}
31
32	/**
33	* Finds the swap order in the transaction data.
34	* The swap order can be in the transaction data directly or in the data of a Multisend transaction.
35	*
36	* @param data - The transaction data
37	* @private
38	* @returns The swap order if found, otherwise null
39	*/
40	public findSwapOrder(data: `0x${string}`): `0x${string}` \| null {
41	// The swap order can be in the transaction data directly
42	if (this.isSwapOrder({ data })) {	74!
NEW 43	return data;	×
44	}
45	// or in the data of a multisend transaction
46	if (this.multiSendDecoder.helpers.isMultiSend(data)) {	74!
NEW 47	const transactions = this.multiSendDecoder.mapMultiSendTransactions(data);	×
48	// TODO If we can build a sorted hash map of the transactions, we can avoid iterating all of them
49	// as we know the pattern of a Swap Order.
NEW 50	for (const transaction of transactions) {	×
NEW 51	if (this.isSwapOrder(transaction)) {	×
NEW 52	return transaction.data;	×
53	}
54	}
55	}
56	return null;	74✔
57	}
58
59	/**
60	* Retrieves detailed information about a specific order and its associated tokens
61	*
62	* @param {Object} args - The arguments required to fetch the order.
63	* @param {string} args.chainId - The network chain ID.
64	* @param {string} args.orderUid - The unique identifier of the order, prefixed with '0x'.
65	* @returns {Promise} A promise that resolves to an object containing the order and token details.
66	*
67	* The returned object includes:
68	* - `order`: An object representing the order.
69	* - `sellToken`: The Token object with a mandatory `decimals` property
70	* - `buyToken`: Similar to `sellToken`, for the token being purchased in the order.
71	*
72	* @throws {Error} Throws an error if the order `kind` is 'unknown'.
73	* @throws {Error} Throws an error if either the sellToken or buyToken object has null decimals.
74	*/
75	async getOrder(args: { chainId: string; orderUid: `0x${string}` }): Promise<{
76	order: Omit<Order, 'kind'> & { kind: Exclude<Order['kind'], 'unknown'> };
77	sellToken: Token & { decimals: number };
78	buyToken: Token & { decimals: number };
79	}> {
80	const order = await this.swapsRepository.getOrder(	18✔
81	args.chainId,
82	args.orderUid,
83	);
84
85	if (order.kind === 'unknown') throw new Error('Unknown order kind');	16✔
86
87	const [buyToken, sellToken] = await Promise.all([	4✔
88	this.tokenRepository.getToken({
89	chainId: args.chainId,
90	address: order.buyToken,
91	}),
92	this.tokenRepository.getToken({
93	chainId: args.chainId,
94	address: order.sellToken,
95	}),
96	]);
97
98	if (buyToken.decimals === null \|\| sellToken.decimals === null) {	2!
NEW 99	throw new Error('Invalid token decimals');	×
100	}
101
102	return {	2✔
103	order: { ...order, kind: order.kind },
104	buyToken: { ...buyToken, decimals: buyToken.decimals },
105	sellToken: { ...sellToken, decimals: sellToken.decimals },
106	};
107	}
108
109	/**
110	* Returns the URL to the explorer page of an order.
111	*
112	* @param order - The order to get the explorer URL for.
113	* @private
114	*/
115	getOrderExplorerUrl(order: Order): URL {
NEW 116	const url = new URL(this.swapsExplorerBaseUri);	×
NEW 117	url.pathname = `/orders/${order.uid}`;	×
NEW 118	return url;	×
119	}
120
121	private isSwapOrder(transaction: { data?: `0x${string}` }): boolean {
122	if (!transaction.data) return false;	74!
123	return this.setPreSignatureDecoder.isSetPreSignature(transaction.data);	74✔
124	}
125	}
126
127	@Module({
128	imports: [SwapsRepositoryModule, TokenRepositoryModule],
129	providers: [SwapOrderHelper, MultiSendDecoder, SetPreSignatureDecoder],
130	exports: [SwapOrderHelper],
131	})
132	export class SwapOrderHelperModule {}	102✔

safe-global / safe-client-gateway / 8781721739

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