9888524057

Committed 11 Jul 2024 09:00AM UTC coverage: 48.265% (+0.08%) from 48.186%

Build # 9888524057

Build Type

push

github

Committed by

web-flow

Commit Message

Add RUN_MIGRATIONS flag to the service configuration (#1753)

Adds RUN_MIGRATIONS (true by default) to control the execution of database migrations at the application bootstrap.
Adds a test suite for PostgresDatabaseMigrationHook.

Run Details

415 of 2589 branches covered (16.03%)

Branch coverage included in aggregate %.

1 of 5 new or added lines in 1 file covered. (20.0%)

113 existing lines in 7 files now uncovered.

4259 of 7095 relevant lines covered (60.03%)

13.04 hits per line

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

16.18

/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';
import { SwapAppsHelper } from '@/routes/transactions/helpers/swap-apps.helper';

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

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

safe-global / safe-client-gateway / 9888524057

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