9830429507

Committed 05 Jul 2024 03:34PM UTC coverage: 48.257% (-0.02%) from 48.272%

Build # 9830429507

Build Type

push

github

Committed by

web-flow

Commit Message

Handle all swap transfer mapping errors (#1733)

Wraps the call to the swap transfer mapper, logging every error accordingly and meaning that the "normal" mapping of transfers will be used as a fallback:

- Always return a mapped transaction from `SwapTransferInfoMapper['mapSwapTransferInfo']`
- Add error handling wrapper that calls the above in to `TransferInfoMapper['mapSwapTransfer']`
- Update tests accordingly

Run Details

412 of 2587 branches covered (15.93%)

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.

4225 of 7022 relevant lines covered (60.17%)

13.11 hits per line

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

20.41

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

import { Inject, Injectable } from '@nestjs/common';
import { Safe } from '@/domain/safe/entities/safe.entity';
import { Transfer as DomainTransfer } from '@/domain/safe/entities/transfer.entity';
import { Token } from '@/domain/tokens/entities/token.entity';
import { TokenRepository } from '@/domain/tokens/token.repository';
import { ITokenRepository } from '@/domain/tokens/token.repository.interface';
import { AddressInfoHelper } from '@/routes/common/address-info/address-info.helper';
import {
  TransferDirection,
  TransferTransactionInfo,
} from '@/routes/transactions/entities/transfer-transaction-info.entity';
import { Erc20Transfer } from '@/routes/transactions/entities/transfers/erc20-transfer.entity';
import { Erc721Transfer } from '@/routes/transactions/entities/transfers/erc721-transfer.entity';
import { NativeCoinTransfer } from '@/routes/transactions/entities/transfers/native-coin-transfer.entity';
import { getTransferDirection } from '@/routes/transactions/mappers/common/transfer-direction.helper';
import { Transfer } from '@/routes/transactions/entities/transfers/transfer.entity';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { SwapTransferInfoMapper } from '@/routes/transactions/mappers/transfers/swap-transfer-info.mapper';
import { SwapTransferTransactionInfo } from '@/routes/transactions/swap-transfer-transaction-info.entity';
import { AddressInfo } from '@/routes/common/entities/address-info.entity';
import { LoggingService, ILoggingService } from '@/logging/logging.interface';

@Injectable()
export class TransferInfoMapper {
  private readonly isSwapsDecodingEnabled: boolean;
  private readonly isTwapsDecodingEnabled: boolean;

  constructor(
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(ITokenRepository) private readonly tokenRepository: TokenRepository,
    private readonly swapTransferInfoMapper: SwapTransferInfoMapper,
    private readonly addressInfoHelper: AddressInfoHelper,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
  ) {
    this.isSwapsDecodingEnabled = this.configurationService.getOrThrow(
      'features.swapsDecoding',
    );
    this.isTwapsDecodingEnabled = this.configurationService.getOrThrow(
      'features.twapsDecoding',
    );
  }

  async mapTransferInfo(
    chainId: string,
    domainTransfer: DomainTransfer,
    safe: Safe,
  ): Promise<SwapTransferTransactionInfo | TransferTransactionInfo> {
    const { from, to } = domainTransfer;

    const [sender, recipient, transferInfo] = await Promise.all([
      this.addressInfoHelper.getOrDefault(chainId, from, ['TOKEN', 'CONTRACT']),
      this.addressInfoHelper.getOrDefault(chainId, to, ['TOKEN', 'CONTRACT']),
      this.getTransferByType(chainId, domainTransfer),
    ]);

    const direction = getTransferDirection(safe.address, from, to);

    if (this.isSwapsDecodingEnabled && this.isTwapsDecodingEnabled) {
      // If the transaction is a swap-based transfer, we return it immediately
      const swapTransfer = await this.mapSwapTransfer({
        sender,
        recipient,
        direction,
        transferInfo,
        chainId,
        safeAddress: safe.address,
        domainTransfer,
      });

      if (swapTransfer) {
        return swapTransfer;
      }
    }

    return new TransferTransactionInfo(
      sender,
      recipient,
      direction,
      transferInfo,
      null,
      null,
    );
  }

  /**
   * Maps a swap transfer transaction.
   * If the transaction is not a swap transfer, it returns null.
   *
   * @param args.sender - {@link AddressInfo} sender of the transfer
   * @param args.recipient - {@link AddressInfo} recipient of the transfer
   * @param args.direction - {@link TransferDirection} of the transfer
   * @param args.chainId - chain id of the transfer
   * @param args.safeAddress - safe address of the transfer
   * @param args.transferInfo - {@link Transfer} info
   * @param args.domainTransfer - {@link DomainTransfer} domain transfer
   */
  private async mapSwapTransfer(args: {
    sender: AddressInfo;
    recipient: AddressInfo;
    direction: TransferDirection;
    chainId: string;
    safeAddress: `0x${string}`;
    transferInfo: Transfer;
    domainTransfer: DomainTransfer;
  }): Promise<SwapTransferTransactionInfo | null> {
    try {
      return await this.swapTransferInfoMapper.mapSwapTransferInfo(args);
    } catch (error) {
      // There were either issues mapping the swap transfer or it is a "normal" transfer
      this.loggingService.warn(error);
      return null;
    }
  }

  private async getTransferByType(
    chainId: string,
    domainTransfer: DomainTransfer,
  ): Promise<Transfer> {
    if (domainTransfer.type === 'ERC20_TRANSFER') {
      const { tokenAddress, value } = domainTransfer;
      const token: Token | null = await this.getToken(
        chainId,
        tokenAddress,
      ).catch(() => null);
      return new Erc20Transfer(
        tokenAddress,
        value,
        token?.name,
        token?.symbol,
        token?.logoUri,
        token?.decimals,
        token?.trusted,
      );
    } else if (domainTransfer.type === 'ERC721_TRANSFER') {
      const { tokenAddress, tokenId } = domainTransfer;
      const token = await this.getToken(chainId, tokenAddress).catch(
        () => null,
      );
      return new Erc721Transfer(
        tokenAddress,
        tokenId,
        token?.name,
        token?.symbol,
        token?.logoUri,
        token?.trusted,
      );
    } else if (domainTransfer.type === 'ETHER_TRANSFER') {
      return new NativeCoinTransfer(domainTransfer.value);
    } else {
      throw Error('Unknown transfer type');
    }
  }

  private getToken(
    chainId: string,
    tokenAddress: string | null,
  ): Promise<Token> {
    if (!tokenAddress) {
      throw Error('Invalid token address for transfer');
    }
    return this.tokenRepository.getToken({ chainId, address: tokenAddress });
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	16✔
2	import { Safe } from '@/domain/safe/entities/safe.entity';
3	import { Transfer as DomainTransfer } from '@/domain/safe/entities/transfer.entity';
4	import { Token } from '@/domain/tokens/entities/token.entity';
5	import { TokenRepository } from '@/domain/tokens/token.repository';	16✔
6	import { ITokenRepository } from '@/domain/tokens/token.repository.interface';	16✔
7	import { AddressInfoHelper } from '@/routes/common/address-info/address-info.helper';	16✔
8	import {	16✔
9	TransferDirection,
10	TransferTransactionInfo,
11	} from '@/routes/transactions/entities/transfer-transaction-info.entity';
12	import { Erc20Transfer } from '@/routes/transactions/entities/transfers/erc20-transfer.entity';	16✔
13	import { Erc721Transfer } from '@/routes/transactions/entities/transfers/erc721-transfer.entity';	16✔
14	import { NativeCoinTransfer } from '@/routes/transactions/entities/transfers/native-coin-transfer.entity';	16✔
15	import { getTransferDirection } from '@/routes/transactions/mappers/common/transfer-direction.helper';	16✔
16	import { Transfer } from '@/routes/transactions/entities/transfers/transfer.entity';
17	import { IConfigurationService } from '@/config/configuration.service.interface';	16✔
18	import { SwapTransferInfoMapper } from '@/routes/transactions/mappers/transfers/swap-transfer-info.mapper';	16✔
19	import { SwapTransferTransactionInfo } from '@/routes/transactions/swap-transfer-transaction-info.entity';
20	import { AddressInfo } from '@/routes/common/entities/address-info.entity';
21	import { LoggingService, ILoggingService } from '@/logging/logging.interface';	16✔
22
23	@Injectable()
24	export class TransferInfoMapper {	16✔
25	private readonly isSwapsDecodingEnabled: boolean;
26	private readonly isTwapsDecodingEnabled: boolean;
27
28	constructor(
29	@Inject(IConfigurationService)
30	private readonly configurationService: IConfigurationService,	16✔
31	@Inject(ITokenRepository) private readonly tokenRepository: TokenRepository,	16✔
32	private readonly swapTransferInfoMapper: SwapTransferInfoMapper,	16✔
33	private readonly addressInfoHelper: AddressInfoHelper,	16✔
34	@Inject(LoggingService) private readonly loggingService: ILoggingService,	16✔
35	) {
36	this.isSwapsDecodingEnabled = this.configurationService.getOrThrow(	16✔
37	'features.swapsDecoding',
38	);
39	this.isTwapsDecodingEnabled = this.configurationService.getOrThrow(	16✔
40	'features.twapsDecoding',
41	);
42	}
43
44	async mapTransferInfo(
45	chainId: string,
46	domainTransfer: DomainTransfer,
47	safe: Safe,
48	): Promise<SwapTransferTransactionInfo \| TransferTransactionInfo> {
49	const { from, to } = domainTransfer;	×
50
51	const [sender, recipient, transferInfo] = await Promise.all([	×
52	this.addressInfoHelper.getOrDefault(chainId, from, ['TOKEN', 'CONTRACT']),
53	this.addressInfoHelper.getOrDefault(chainId, to, ['TOKEN', 'CONTRACT']),
54	this.getTransferByType(chainId, domainTransfer),
55	]);
56
57	const direction = getTransferDirection(safe.address, from, to);	×
58
59	if (this.isSwapsDecodingEnabled && this.isTwapsDecodingEnabled) {	×
60	// If the transaction is a swap-based transfer, we return it immediately
NEW 61	const swapTransfer = await this.mapSwapTransfer({	×
62	sender,
63	recipient,
64	direction,
65	transferInfo,
66	chainId,
67	safeAddress: safe.address,
68	domainTransfer,
69	});
70
71	if (swapTransfer) {	×
72	return swapTransfer;	×
73	}
74	}
75
76	return new TransferTransactionInfo(	×
77	sender,
78	recipient,
79	direction,
80	transferInfo,
81	null,
82	null,
83	);
84	}
85
86	/**
87	* Maps a swap transfer transaction.
88	* If the transaction is not a swap transfer, it returns null.
89	*
90	* @param args.sender - {@link AddressInfo} sender of the transfer
91	* @param args.recipient - {@link AddressInfo} recipient of the transfer
92	* @param args.direction - {@link TransferDirection} of the transfer
93	* @param args.chainId - chain id of the transfer
94	* @param args.safeAddress - safe address of the transfer
95	* @param args.transferInfo - {@link Transfer} info
96	* @param args.domainTransfer - {@link DomainTransfer} domain transfer
97	*/
98	private async mapSwapTransfer(args: {
99	sender: AddressInfo;
100	recipient: AddressInfo;
101	direction: TransferDirection;
102	chainId: string;
103	safeAddress: `0x${string}`;
104	transferInfo: Transfer;
105	domainTransfer: DomainTransfer;
106	}): Promise<SwapTransferTransactionInfo \| null> {
NEW 107	try {	×
NEW 108	return await this.swapTransferInfoMapper.mapSwapTransferInfo(args);	×
109	} catch (error) {
110	// There were either issues mapping the swap transfer or it is a "normal" transfer
NEW 111	this.loggingService.warn(error);	×
NEW 112	return null;	×
113	}
114	}
115
116	private async getTransferByType(
117	chainId: string,
118	domainTransfer: DomainTransfer,
119	): Promise<Transfer> {
120	if (domainTransfer.type === 'ERC20_TRANSFER') {	×
121	const { tokenAddress, value } = domainTransfer;	×
122	const token: Token \| null = await this.getToken(	×
123	chainId,
124	tokenAddress,
125	).catch(() => null);	×
126	return new Erc20Transfer(	×
127	tokenAddress,
128	value,
129	token?.name,	×
130	token?.symbol,	×
131	token?.logoUri,	×
132	token?.decimals,	×
133	token?.trusted,	×
134	);
135	} else if (domainTransfer.type === 'ERC721_TRANSFER') {	×
136	const { tokenAddress, tokenId } = domainTransfer;	×
137	const token = await this.getToken(chainId, tokenAddress).catch(	×
138	() => null,	×
139	);
140	return new Erc721Transfer(	×
141	tokenAddress,
142	tokenId,
143	token?.name,	×
144	token?.symbol,	×
145	token?.logoUri,	×
146	token?.trusted,	×
147	);
148	} else if (domainTransfer.type === 'ETHER_TRANSFER') {	×
149	return new NativeCoinTransfer(domainTransfer.value);	×
150	} else {
151	throw Error('Unknown transfer type');	×
152	}
153	}
154
155	private getToken(
156	chainId: string,
157	tokenAddress: string \| null,
158	): Promise<Token> {
159	if (!tokenAddress) {	×
160	throw Error('Invalid token address for transfer');	×
161	}
162	return this.tokenRepository.getToken({ chainId, address: tokenAddress });	×
163	}
164	}

safe-global / safe-client-gateway / 9830429507

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