9684668354

Committed 26 Jun 2024 06:12PM UTC coverage: 48.808% (+0.08%) from 48.728%

Build # 9684668354

Build Type

Pull #1691

github

Committed by

hectorgomezv

Commit Message

Adjust unit tests data

Pull Request Pull Request #1691: Map swap-related transfers

Run Details

412 of 2506 branches covered (16.44%)

Branch coverage included in aggregate %.

53 of 102 new or added lines in 11 files covered. (51.96%)

1 existing line in 1 file now uncovered.

4193 of 6929 relevant lines covered (60.51%)

13.21 hits per line

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

15.25

/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 | null> {
    // If settlement contract is not interacted with, not a swap fulfillment
    if (
      !this.isSettlement(args.sender.value) &&
      !this.isSettlement(args.recipient.value)
    ) {
      return null;
    }

    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) {
      return null;
    }

    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 \| null> {
42	// If settlement contract is not interacted with, not a swap fulfillment
NEW 43	if (	×
44	!this.isSettlement(args.sender.value) &&	×
45	!this.isSettlement(args.recipient.value)
46	) {
NEW 47	return null;	×
48	}
49
NEW 50	const orders = await this.swapsRepository.getOrders(	×
51	args.chainId,
52	args.domainTransfer.transactionHash,
53	);
54
55	// One transaction may contain multiple orders
NEW 56	const order = this.findOrderByTransfer(orders, args.domainTransfer);	×
57
NEW 58	if (!order) {	×
NEW 59	return null;	×
60	}
61
NEW 62	const [sellToken, buyToken] = await Promise.all([	×
63	this.swapOrderHelper.getToken({
64	address: order.sellToken,
65	chainId: args.chainId,
66	}),
67	this.swapOrderHelper.getToken({
68	address: order.buyToken,
69	chainId: args.chainId,
70	}),
71	]);
72
NEW 73	return new SwapTransferTransactionInfo({	×
74	// TransferTransactionInfo
75	sender: args.sender,
76	recipient: args.recipient,
77	direction: args.direction,
78	transferInfo: args.transferInfo,
79	humanDescription: null,
80	richDecodedInfo: null,
81	// SwapOrderTransactionInfo
82	uid: order.uid,
83	orderStatus: order.status,
84	kind: order.kind,
85	class: order.class,
86	validUntil: order.validTo,
87	sellAmount: order.sellAmount.toString(),
88	buyAmount: order.buyAmount.toString(),
89	executedSellAmount: order.executedSellAmount.toString(),
90	executedBuyAmount: order.executedBuyAmount.toString(),
91	sellToken,
92	buyToken,
93	explorerUrl: this.swapOrderHelper.getOrderExplorerUrl(order).toString(),
94	executedSurplusFee: order.executedSurplusFee?.toString() ?? null,	×
95	receiver: order.receiver,
96	owner: order.owner,
97	fullAppData: order.fullAppData,
98	});
99	}
100
101	private isSettlement(address: string): boolean {
NEW 102	return isAddressEqual(	×
103	getAddress(address),
104	GPv2OrderHelper.SettlementContractAddress,
105	);
106	}
107
108	/**
109	* Finds a order by transfer by comparing the token address and value of the transfer
110	* with the order's sellToken and buyToken.
111	*
112	* @param orders
113	* @param transfer
114	* @returns the {@link Order} if found, otherwise `undefined`
115	*/
116	private findOrderByTransfer(
117	orders: Array<Order>,
118	transfer: DomainTransfer,
119	): Order \| undefined {
NEW 120	return orders.find((order) => {	×
NEW 121	if (transfer.type === 'ERC721_TRANSFER') {	×
NEW 122	throw new Error('ERC721 transfers are not supported by swaps');	×
123	}
124
NEW 125	const isSender = transfer.from === order.owner;	×
126
NEW 127	const isValue = isSender	×
128	? transfer.value === order.executedSellAmount.toString()
129	: transfer.value === order.executedBuyAmount.toString();
130
NEW 131	const isToken = ((): boolean => {	×
NEW 132	const tokenToCompare = isSender ? order.sellToken : order.buyToken;	×
133
NEW 134	if (transfer.type === 'ETHER_TRANSFER') {	×
NEW 135	return tokenToCompare === SwapOrderHelper.NATIVE_CURRENCY_ADDRESS;	×
136	}
NEW 137	if (transfer.type === 'ERC20_TRANSFER') {	×
NEW 138	return tokenToCompare === transfer.tokenAddress;	×
139	}
140
NEW 141	return false;	×
142	})();
143
NEW 144	return isValue && isToken;	×
145	});
146	}
147	}

safe-global / safe-client-gateway / 9684668354

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