9807927487

Committed 05 Jul 2024 11:59AM UTC coverage: 48.298% (+0.03%) from 48.272%

Build # 9807927487

Build Type

push

github

Committed by

iamacook

Commit Message

Handle all swap transfer mapping errors

Run Details

414 of 2587 branches covered (16.0%)

Branch coverage included in aggregate %.

3 of 11 new or added lines in 2 files covered. (27.27%)

2 existing lines in 1 file now uncovered.

4227 of 7022 relevant lines covered (60.2%)

13.11 hits per line

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

13.64

/src/routes/transactions/mappers/transfers/swap-transfer-info.mapper.ts

import { Inject, Injectable } from '@nestjs/common';
import { Transfer as DomainTransfer } from '@/domain/safe/entities/transfer.entity';
import { TransferDirection } from '@/routes/transactions/entities/transfer-transaction-info.entity';
import { Transfer } from '@/routes/transactions/entities/transfers/transfer.entity';
import { GPv2OrderHelper } from '@/routes/transactions/helpers/gp-v2-order.helper';
import { SwapOrderHelper } from '@/routes/transactions/helpers/swap-order.helper';
import { AddressInfo } from '@/routes/common/entities/address-info.entity';
import { SwapTransferTransactionInfo } from '@/routes/transactions/swap-transfer-transaction-info.entity';
import { getAddress, isAddressEqual } from 'viem';
import { ISwapsRepository } from '@/domain/swaps/swaps.repository';
import { Order } from '@/domain/swaps/entities/order.entity';

@Injectable()
export class SwapTransferInfoMapper {
  constructor(
    private readonly swapOrderHelper: SwapOrderHelper,
    @Inject(ISwapsRepository)
    private readonly swapsRepository: ISwapsRepository,
  ) {}

  /**
   * Maps a swap transfer transaction info
   *
   * @param args.sender - {@link AddrssInfo} sender of the transfer
   * @param args.recipient - {@link AddrssInfo} recipient of the transfer
   * @param args.direction - {@link TransferDirection} direction of the transfer
   * @param args.chainId - chain id of the transfer
   * @param args.safeAddress - safe address of the transfer
   * @param args.transferInfo - {@link TransferInfo} transfer info
   * @param args.domainTransfer - {@link Transfer} domain transfer (used to find the order)
   * @returns
   */
  public async mapSwapTransferInfo(args: {
    sender: AddressInfo;
    recipient: AddressInfo;
    direction: TransferDirection;
    chainId: string;
    safeAddress: `0x${string}`;
    transferInfo: Transfer;
    domainTransfer: DomainTransfer;
  }): Promise<SwapTransferTransactionInfo> {
    // If settlement contract is not interacted with, not a swap fulfillment
    // TODO: Also check data is of `settle` call as otherwise _any_ call
    // to settlement contract could be considered a swap fulfillment
    if (
      !this.isSettlement(args.sender.value) &&
      !this.isSettlement(args.recipient.value)
    ) {
      throw new Error('Neither sender nor receiver are settlement contract');
    }

    const orders = await this.swapsRepository.getOrders(
      args.chainId,
      args.domainTransfer.transactionHash,
    );

    // One transaction may contain multiple orders
    const order = this.findOrderByTransfer(orders, args.domainTransfer);

    if (!order) {
      throw new Error('Transfer not found in order');
    }

    if (!this.swapOrderHelper.isAppAllowed(order)) {
      throw new Error(`Unsupported App: ${order.fullAppData?.appCode}`);
    }

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

    return new SwapTransferTransactionInfo({
      // TransferTransactionInfo
      sender: args.sender,
      recipient: args.recipient,
      direction: args.direction,
      transferInfo: args.transferInfo,
      humanDescription: null,
      richDecodedInfo: null,
      // SwapOrderTransactionInfo
      uid: order.uid,
      orderStatus: order.status,
      kind: order.kind,
      class: order.class,
      validUntil: order.validTo,
      sellAmount: order.sellAmount.toString(),
      buyAmount: order.buyAmount.toString(),
      executedSellAmount: order.executedSellAmount.toString(),
      executedBuyAmount: order.executedBuyAmount.toString(),
      sellToken,
      buyToken,
      explorerUrl: this.swapOrderHelper.getOrderExplorerUrl(order).toString(),
      executedSurplusFee: order.executedSurplusFee?.toString() ?? null,
      receiver: order.receiver,
      owner: order.owner,
      fullAppData: order.fullAppData,
    });
  }

  private isSettlement(address: string): boolean {
    return isAddressEqual(
      getAddress(address),
      GPv2OrderHelper.SettlementContractAddress,
    );
  }

  /**
   * Finds a order by transfer by comparing the token address and value of the transfer
   * with the order's sellToken and buyToken.
   *
   * @param orders
   * @param transfer
   * @returns the {@link Order} if found, otherwise `undefined`
   */
  private findOrderByTransfer(
    orders: Array<Order>,
    transfer: DomainTransfer,
  ): Order | undefined {
    return orders.find((order) => {
      if (transfer.type === 'ERC721_TRANSFER') {
        throw new Error('ERC721 transfers are not supported by swaps');
      }

      const isSender = transfer.from === order.owner;

      const isValue = isSender
        ? transfer.value === order.executedSellAmount.toString()
        : transfer.value === order.executedBuyAmount.toString();

      const isToken = ((): boolean => {
        const tokenToCompare = isSender ? order.sellToken : order.buyToken;

        if (transfer.type === 'ETHER_TRANSFER') {
          return tokenToCompare === SwapOrderHelper.NATIVE_CURRENCY_ADDRESS;
        }
        if (transfer.type === 'ERC20_TRANSFER') {
          return tokenToCompare === transfer.tokenAddress;
        }

        return false;
      })();

      return isValue && isToken;
    });
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	16✔
2	import { Transfer as DomainTransfer } from '@/domain/safe/entities/transfer.entity';
3	import { TransferDirection } from '@/routes/transactions/entities/transfer-transaction-info.entity';
4	import { Transfer } from '@/routes/transactions/entities/transfers/transfer.entity';
5	import { GPv2OrderHelper } from '@/routes/transactions/helpers/gp-v2-order.helper';	16✔
6	import { SwapOrderHelper } from '@/routes/transactions/helpers/swap-order.helper';	16✔
7	import { AddressInfo } from '@/routes/common/entities/address-info.entity';
8	import { SwapTransferTransactionInfo } from '@/routes/transactions/swap-transfer-transaction-info.entity';	16✔
9	import { getAddress, isAddressEqual } from 'viem';	16✔
10	import { ISwapsRepository } from '@/domain/swaps/swaps.repository';	16✔
11	import { Order } from '@/domain/swaps/entities/order.entity';
12
13	@Injectable()
14	export class SwapTransferInfoMapper {	16✔
15	constructor(
16	private readonly swapOrderHelper: SwapOrderHelper,	16✔
17	@Inject(ISwapsRepository)
18	private readonly swapsRepository: ISwapsRepository,	16✔
19	) {}
20
21	/**
22	* Maps a swap transfer transaction info
23	*
24	* @param args.sender - {@link AddrssInfo} sender of the transfer
25	* @param args.recipient - {@link AddrssInfo} recipient of the transfer
26	* @param args.direction - {@link TransferDirection} direction of the transfer
27	* @param args.chainId - chain id of the transfer
28	* @param args.safeAddress - safe address of the transfer
29	* @param args.transferInfo - {@link TransferInfo} transfer info
30	* @param args.domainTransfer - {@link Transfer} domain transfer (used to find the order)
31	* @returns
32	*/
33	public async mapSwapTransferInfo(args: {
34	sender: AddressInfo;
35	recipient: AddressInfo;
36	direction: TransferDirection;
37	chainId: string;
38	safeAddress: `0x${string}`;
39	transferInfo: Transfer;
40	domainTransfer: DomainTransfer;
41	}): Promise<SwapTransferTransactionInfo> {
42	// If settlement contract is not interacted with, not a swap fulfillment
43	// TODO: Also check data is of `settle` call as otherwise _any_ call
44	// to settlement contract could be considered a swap fulfillment
UNCOV 45	if (	×
46	!this.isSettlement(args.sender.value) &&	×
47	!this.isSettlement(args.recipient.value)
48	) {
NEW 49	throw new Error('Neither sender nor receiver are settlement contract');	×
50	}
51
52	const orders = await this.swapsRepository.getOrders(	×
53	args.chainId,
54	args.domainTransfer.transactionHash,
55	);
56
57	// One transaction may contain multiple orders
58	const order = this.findOrderByTransfer(orders, args.domainTransfer);	×
59
60	if (!order) {	×
NEW 61	throw new Error('Transfer not found in order');	×
62	}
63
UNCOV 64	if (!this.swapOrderHelper.isAppAllowed(order)) {	×
NEW 65	throw new Error(`Unsupported App: ${order.fullAppData?.appCode}`);	×
66	}
67
68	const [sellToken, buyToken] = await Promise.all([	×
69	this.swapOrderHelper.getToken({
70	address: order.sellToken,
71	chainId: args.chainId,
72	}),
73	this.swapOrderHelper.getToken({
74	address: order.buyToken,
75	chainId: args.chainId,
76	}),
77	]);
78
79	return new SwapTransferTransactionInfo({	×
80	// TransferTransactionInfo
81	sender: args.sender,
82	recipient: args.recipient,
83	direction: args.direction,
84	transferInfo: args.transferInfo,
85	humanDescription: null,
86	richDecodedInfo: null,
87	// SwapOrderTransactionInfo
88	uid: order.uid,
89	orderStatus: order.status,
90	kind: order.kind,
91	class: order.class,
92	validUntil: order.validTo,
93	sellAmount: order.sellAmount.toString(),
94	buyAmount: order.buyAmount.toString(),
95	executedSellAmount: order.executedSellAmount.toString(),
96	executedBuyAmount: order.executedBuyAmount.toString(),
97	sellToken,
98	buyToken,
99	explorerUrl: this.swapOrderHelper.getOrderExplorerUrl(order).toString(),
100	executedSurplusFee: order.executedSurplusFee?.toString() ?? null,	×
101	receiver: order.receiver,
102	owner: order.owner,
103	fullAppData: order.fullAppData,
104	});
105	}
106
107	private isSettlement(address: string): boolean {
108	return isAddressEqual(	×
109	getAddress(address),
110	GPv2OrderHelper.SettlementContractAddress,
111	);
112	}
113
114	/**
115	* Finds a order by transfer by comparing the token address and value of the transfer
116	* with the order's sellToken and buyToken.
117	*
118	* @param orders
119	* @param transfer
120	* @returns the {@link Order} if found, otherwise `undefined`
121	*/
122	private findOrderByTransfer(
123	orders: Array<Order>,
124	transfer: DomainTransfer,
125	): Order \| undefined {
126	return orders.find((order) => {	×
127	if (transfer.type === 'ERC721_TRANSFER') {	×
128	throw new Error('ERC721 transfers are not supported by swaps');	×
129	}
130
131	const isSender = transfer.from === order.owner;	×
132
133	const isValue = isSender	×
134	? transfer.value === order.executedSellAmount.toString()
135	: transfer.value === order.executedBuyAmount.toString();
136
137	const isToken = ((): boolean => {	×
138	const tokenToCompare = isSender ? order.sellToken : order.buyToken;	×
139
140	if (transfer.type === 'ETHER_TRANSFER') {	×
141	return tokenToCompare === SwapOrderHelper.NATIVE_CURRENCY_ADDRESS;	×
142	}
143	if (transfer.type === 'ERC20_TRANSFER') {	×
144	return tokenToCompare === transfer.tokenAddress;	×
145	}
146
147	return false;	×
148	})();
149
150	return isValue && isToken;	×
151	});
152	}
153	}

safe-global / safe-client-gateway / 9807927487

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