8524598827

Committed 02 Apr 2024 02:31PM UTC coverage: 93.105% (-0.2%) from 93.342%

Build # 8524598827

Build Type

push

github

Committed by

web-flow

Commit Message

Add support for decoding Swap Orders in Multisends (#1348)

- Swap Orders inside a Multisend should be decoded in the same way as regular ones.
- Detection of a Multisend order happens on the first level of transactions (i.e. it does not detect Swap transactions if a Multisend contains another Multisend).
- The `mapSwapOrder` function also changed:
  * It is no longer restricted to a `MultisigTransaction` or `ModuleTransaction` – this was done to support nested transactions which do not have all the properties of a Multisig or Module transactions.
  * It no longer maps to a `CustomTransactionInfo` – this is now a decision left for the callers. Instead, the promise is rejected if the swap transaction couldn't be decoded successfully.

Run Details

1853 of 2244 branches covered (82.58%)

Branch coverage included in aggregate %.

25 of 35 new or added lines in 3 files covered. (71.43%)

2 existing lines in 1 file now uncovered.

6492 of 6719 relevant lines covered (96.62%)

362.92 hits per line

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

88.64

/src/routes/transactions/mappers/common/swap-order.mapper.ts

import { Inject, Injectable, Module } from '@nestjs/common';
import { SetPreSignatureDecoder } from '@/domain/swaps/contracts/decoders/set-pre-signature-decoder.helper';
import {
  DefaultSwapOrderTransactionInfo,
  FulfilledSwapOrderTransactionInfo,
  SwapOrderTransactionInfo,
  TokenInfo,
} from '@/routes/transactions/entities/swap-order-info.entity';
import { ITokenRepository } from '@/domain/tokens/token.repository.interface';
import { Token } from '@/domain/tokens/entities/token.entity';
import { SwapsRepository } from '@/domain/swaps/swaps.repository';
import { SwapsModule } from '@/domain/swaps/swaps.module';
import { Order } from '@/domain/swaps/entities/order.entity';
import { IConfigurationService } from '@/config/configuration.service.interface';

/**
 * Represents the amount of a token in a swap order.
 */
class TokenAmount {
  readonly token: Token & {
    decimals: number;
  };
  private readonly amount: bigint;
  private readonly executedAmount: bigint;

  constructor(args: { token: Token; amount: bigint; executedAmount: bigint }) {
    if (args.token.decimals === null)
      throw new Error(`Token ${args.token.address} has no decimals set.`);

    this.token = { ...args.token, decimals: args.token.decimals };
    this.amount = args.amount;
    this.executedAmount = args.executedAmount;
  }

  getAmount(): number {
    return asDecimal(this.amount, this.token.decimals);
  }

  getExecutedAmount(): number {
    return asDecimal(this.executedAmount, this.token.decimals);
  }

  toTokenInfo(): TokenInfo {
    return new TokenInfo({
      amount: this.getAmount().toString(),
      symbol: this.token.symbol,
      logo: this.token.logoUri,
    });
  }
}

function asDecimal(amount: number | bigint, decimals: number): number {
  return Number(amount) / 10 ** decimals;
}

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

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

  async mapSwapOrder(
    chainId: string,
    transaction: { data: `0x${string}` },
  ): Promise<SwapOrderTransactionInfo> {
    const orderUid: `0x${string}` | null =
      this.setPreSignatureDecoder.getOrderUid(transaction.data);
    if (!orderUid) {
      throw new Error('Order UID not found in transaction data');
    }

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

    const buyTokenAmount = new TokenAmount({
      token: buyToken,
      amount: order.buyAmount,
      executedAmount: order.executedBuyAmount,
    });
    const sellTokenAmount = new TokenAmount({
      token: sellToken,
      amount: order.sellAmount,
      executedAmount: order.executedSellAmount,
    });

    switch (order.status) {
      case 'fulfilled':
        return this._mapFulfilledOrderStatus({
          buyToken: buyTokenAmount,
          sellToken: sellTokenAmount,
          order,
        });
      case 'open':
      case 'cancelled':
      case 'expired':
        return this._mapDefaultOrderStatus({
          buyToken: buyTokenAmount,
          sellToken: sellTokenAmount,
          order,
        });
      default:
        throw new Error(`Unknown order status: ${order.status}`);
    }
  }

  private _getExecutionPriceLabel(
    sellToken: TokenAmount,
    buyToken: TokenAmount,
  ): string {
    const ratio = sellToken.getExecutedAmount() / buyToken.getExecutedAmount();
    return `1 ${sellToken.token.symbol} = ${ratio} ${buyToken.token.symbol}`;
  }

  private _getLimitPriceLabel(
    sellToken: TokenAmount,
    buyToken: TokenAmount,
  ): string {
    const ratio = sellToken.getAmount() / buyToken.getAmount();
    return `1 ${sellToken.token.symbol} = ${ratio} ${buyToken.token.symbol}`;
  }

  /**
   * Returns the filled percentage of an order.
   * The percentage is calculated as the ratio of the executed amount to the total amount.
   *
   * @param order - The order to calculate the filled percentage for.
   * @private
   */
  private _getFilledPercentage(order: Order): string {
    let executed: number;
    let total: number;
    if (order.kind === 'buy') {
      executed = Number(order.executedBuyAmount);
      total = Number(order.buyAmount);
    } else if (order.kind === 'sell') {
      executed = Number(order.executedSellAmount);
      total = Number(order.sellAmount);
    } else {
      throw new Error('Unknown order kind');
    }

    return ((executed / total) * 100).toFixed(2).toString();
  }

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

  private _mapFulfilledOrderStatus(args: {
    buyToken: TokenAmount;
    sellToken: TokenAmount;
    order: Order;
  }): SwapOrderTransactionInfo {
    if (args.order.kind === 'unknown') {
      throw new Error('Unknown order kind');
    }
    const surplusFeeLabel: string | null = args.order.executedSurplusFee
      ? this._getExecutedSurplusFeeLabel(
          args.order.executedSurplusFee,
          args.buyToken.token,
        )
      : null;

    return new FulfilledSwapOrderTransactionInfo({
      orderUid: args.order.uid,
      orderKind: args.order.kind,
      sellToken: args.sellToken.toTokenInfo(),
      buyToken: args.buyToken.toTokenInfo(),
      expiresTimestamp: args.order.validTo,
      surplusFeeLabel: surplusFeeLabel,
      executionPriceLabel: this._getExecutionPriceLabel(
        args.sellToken,
        args.buyToken,
      ),
      filledPercentage: this._getFilledPercentage(args.order),
      explorerUrl: this._getOrderExplorerUrl(args.order),
    });
  }

  private _getExecutedSurplusFeeLabel(
    executedSurplusFee: bigint,
    token: Token & { decimals: number },
  ): string {
    const surplus = asDecimal(executedSurplusFee, token.decimals);
    return `${surplus} ${token.symbol}`;
  }

  private _mapDefaultOrderStatus(args: {
    buyToken: TokenAmount;
    sellToken: TokenAmount;
    order: Order;
  }): SwapOrderTransactionInfo {
    if (args.order.kind === 'unknown') {
      throw new Error('Unknown order kind');
    }
    if (
      args.order.status === 'fulfilled' ||
      args.order.status === 'presignaturePending' ||
      args.order.status === 'unknown'
    )
      throw new Error(
        `${args.order.status} orders should not be mapped as default orders. Order UID = ${args.order.uid}`,
      );
    return new DefaultSwapOrderTransactionInfo({
      orderUid: args.order.uid,
      status: args.order.status,
      orderKind: args.order.kind,
      sellToken: args.sellToken.toTokenInfo(),
      buyToken: args.buyToken.toTokenInfo(),
      expiresTimestamp: args.order.validTo,
      limitPriceLabel: this._getLimitPriceLabel(args.sellToken, args.buyToken),
      filledPercentage: this._getFilledPercentage(args.order),
      explorerUrl: this._getOrderExplorerUrl(args.order),
    });
  }
}

@Module({
  imports: [SwapsModule],
  providers: [SwapOrderMapper, SetPreSignatureDecoder],
  exports: [SwapOrderMapper],
})
export class SwapOrderMapperModule {}

1	import { Inject, Injectable, Module } from '@nestjs/common';	100✔
2	import { SetPreSignatureDecoder } from '@/domain/swaps/contracts/decoders/set-pre-signature-decoder.helper';	100✔
3	import {	100✔
4	DefaultSwapOrderTransactionInfo,
5	FulfilledSwapOrderTransactionInfo,
6	SwapOrderTransactionInfo,
7	TokenInfo,
8	} from '@/routes/transactions/entities/swap-order-info.entity';
9	import { ITokenRepository } from '@/domain/tokens/token.repository.interface';	100✔
10	import { Token } from '@/domain/tokens/entities/token.entity';
11	import { SwapsRepository } from '@/domain/swaps/swaps.repository';	100✔
12	import { SwapsModule } from '@/domain/swaps/swaps.module';	100✔
13	import { Order } from '@/domain/swaps/entities/order.entity';
14	import { IConfigurationService } from '@/config/configuration.service.interface';	100✔
15
16	/**
17	* Represents the amount of a token in a swap order.
18	*/
19	class TokenAmount {
20	readonly token: Token & {
21	decimals: number;
22	};
23	private readonly amount: bigint;
24	private readonly executedAmount: bigint;
25
26	constructor(args: { token: Token; amount: bigint; executedAmount: bigint }) {
27	if (args.token.decimals === null)	48!
28	throw new Error(`Token ${args.token.address} has no decimals set.`);	×
29
30	this.token = { ...args.token, decimals: args.token.decimals };	48✔
31	this.amount = args.amount;	48✔
32	this.executedAmount = args.executedAmount;	48✔
33	}
34
35	getAmount(): number {
36	return asDecimal(this.amount, this.token.decimals);	52✔
37	}
38
39	getExecutedAmount(): number {
40	return asDecimal(this.executedAmount, this.token.decimals);	12✔
41	}
42
43	toTokenInfo(): TokenInfo {
44	return new TokenInfo({	32✔
45	amount: this.getAmount().toString(),
46	symbol: this.token.symbol,
47	logo: this.token.logoUri,
48	});
49	}
50	}
51
52	function asDecimal(amount: number \| bigint, decimals: number): number {
53	return Number(amount) / 10 ** decimals;	66✔
54	}
55
56	@Injectable()
57	export class SwapOrderMapper {	100✔
58	private readonly swapsExplorerBaseUri: string =	1,236✔
59	this.configurationService.getOrThrow('swaps.explorerBaseUri');
60
61	constructor(
62	private readonly swapsRepository: SwapsRepository,	1,236✔
63	private readonly setPreSignatureDecoder: SetPreSignatureDecoder,	1,236✔
64	@Inject(ITokenRepository)
65	private readonly tokenRepository: ITokenRepository,	1,236✔
66	@Inject(IConfigurationService)
67	private readonly configurationService: IConfigurationService,	1,236✔
68	) {}
69
70	async mapSwapOrder(
71	chainId: string,
72	transaction: { data: `0x${string}` },
73	): Promise<SwapOrderTransactionInfo> {
74	const orderUid: `0x${string}` \| null =
75	this.setPreSignatureDecoder.getOrderUid(transaction.data);	30✔
76	if (!orderUid) {	30✔
77	throw new Error('Order UID not found in transaction data');	2✔
78	}
79
80	const order = await this.swapsRepository.getOrder(chainId, orderUid);	28✔
81	const [buyToken, sellToken] = await Promise.all([	26✔
82	this.tokenRepository.getToken({
83	chainId,
84	address: order.buyToken,
85	}),
86	this.tokenRepository.getToken({
87	chainId,
88	address: order.sellToken,
89	}),
90	]);
91
92	const buyTokenAmount = new TokenAmount({	24✔
93	token: buyToken,
94	amount: order.buyAmount,
95	executedAmount: order.executedBuyAmount,
96	});
97	const sellTokenAmount = new TokenAmount({	24✔
98	token: sellToken,
99	amount: order.sellAmount,
100	executedAmount: order.executedSellAmount,
101	});
102
103	switch (order.status) {	24!
104	case 'fulfilled':
105	return this._mapFulfilledOrderStatus({	8✔
106	buyToken: buyTokenAmount,
107	sellToken: sellTokenAmount,
108	order,
109	});
110	case 'open':
111	case 'cancelled':
112	case 'expired':
113	return this._mapDefaultOrderStatus({	16✔
114	buyToken: buyTokenAmount,
115	sellToken: sellTokenAmount,
116	order,
117	});
118	default:
NEW 119	throw new Error(`Unknown order status: ${order.status}`);	×
120	}
121	}
122
123	private _getExecutionPriceLabel(
124	sellToken: TokenAmount,
125	buyToken: TokenAmount,
126	): string {
127	const ratio = sellToken.getExecutedAmount() / buyToken.getExecutedAmount();	6✔
128	return `1 ${sellToken.token.symbol} = ${ratio} ${buyToken.token.symbol}`;	6✔
129	}
130
131	private _getLimitPriceLabel(
132	sellToken: TokenAmount,
133	buyToken: TokenAmount,
134	): string {
135	const ratio = sellToken.getAmount() / buyToken.getAmount();	10✔
136	return `1 ${sellToken.token.symbol} = ${ratio} ${buyToken.token.symbol}`;	10✔
137	}
138
139	/**
140	* Returns the filled percentage of an order.
141	* The percentage is calculated as the ratio of the executed amount to the total amount.
142	*
143	* @param order - The order to calculate the filled percentage for.
144	* @private
145	*/
146	private _getFilledPercentage(order: Order): string {
147	let executed: number;
148	let total: number;
149	if (order.kind === 'buy') {	16✔
150	executed = Number(order.executedBuyAmount);	4✔
151	total = Number(order.buyAmount);	4✔
152	} else if (order.kind === 'sell') {	12!
153	executed = Number(order.executedSellAmount);	12✔
154	total = Number(order.sellAmount);	12✔
155	} else {
156	throw new Error('Unknown order kind');	×
157	}
158
159	return ((executed / total) * 100).toFixed(2).toString();	16✔
160	}
161
162	/**
163	* Returns the URL to the explorer page of an order.
164	*
165	* @param order - The order to get the explorer URL for.
166	* @private
167	*/
168	private _getOrderExplorerUrl(order: Order): URL {
169	const url = new URL(this.swapsExplorerBaseUri);	16✔
170	url.pathname = `/orders/${order.uid}`;	16✔
171	return url;	16✔
172	}
173
174	private _mapFulfilledOrderStatus(args: {
175	buyToken: TokenAmount;
176	sellToken: TokenAmount;
177	order: Order;
178	}): SwapOrderTransactionInfo {
179	if (args.order.kind === 'unknown') {	8✔
180	throw new Error('Unknown order kind');	2✔
181	}
182	const surplusFeeLabel: string \| null = args.order.executedSurplusFee	6✔
183	? this._getExecutedSurplusFeeLabel(
184	args.order.executedSurplusFee,
185	args.buyToken.token,
186	)
187	: null;
188
189	return new FulfilledSwapOrderTransactionInfo({	6✔
190	orderUid: args.order.uid,
191	orderKind: args.order.kind,
192	sellToken: args.sellToken.toTokenInfo(),
193	buyToken: args.buyToken.toTokenInfo(),
194	expiresTimestamp: args.order.validTo,
195	surplusFeeLabel: surplusFeeLabel,
196	executionPriceLabel: this._getExecutionPriceLabel(
197	args.sellToken,
198	args.buyToken,
199	),
200	filledPercentage: this._getFilledPercentage(args.order),
201	explorerUrl: this._getOrderExplorerUrl(args.order),
202	});
203	}
204
205	private _getExecutedSurplusFeeLabel(
206	executedSurplusFee: bigint,
207	token: Token & { decimals: number },
208	): string {
209	const surplus = asDecimal(executedSurplusFee, token.decimals);	2✔
210	return `${surplus} ${token.symbol}`;	2✔
211	}
212
213	private _mapDefaultOrderStatus(args: {
214	buyToken: TokenAmount;
215	sellToken: TokenAmount;
216	order: Order;
217	}): SwapOrderTransactionInfo {
218	if (args.order.kind === 'unknown') {	16✔
219	throw new Error('Unknown order kind');	6✔
220	}
221	if (	10!
222	args.order.status === 'fulfilled' \|\|	15✔
223	args.order.status === 'presignaturePending' \|\|
224	args.order.status === 'unknown'
225	)
226	throw new Error(	×
227	`${args.order.status} orders should not be mapped as default orders. Order UID = ${args.order.uid}`,
228	);
229	return new DefaultSwapOrderTransactionInfo({	10✔
230	orderUid: args.order.uid,
231	status: args.order.status,
232	orderKind: args.order.kind,
233	sellToken: args.sellToken.toTokenInfo(),
234	buyToken: args.buyToken.toTokenInfo(),
235	expiresTimestamp: args.order.validTo,
236	limitPriceLabel: this._getLimitPriceLabel(args.sellToken, args.buyToken),
237	filledPercentage: this._getFilledPercentage(args.order),
238	explorerUrl: this._getOrderExplorerUrl(args.order),
239	});
240	}
241	}
242
243	@Module({
244	imports: [SwapsModule],
245	providers: [SwapOrderMapper, SetPreSignatureDecoder],
246	exports: [SwapOrderMapper],
247	})
248	export class SwapOrderMapperModule {}	100✔

safe-global / safe-client-gateway / 8524598827

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