9662772307

Committed 25 Jun 2024 12:50PM UTC coverage: 48.919% (+0.2%) from 48.671%

Build # 9662772307

Build Type

push

github

Committed by

iamacook

Commit Message

Map swap-related transfers

Run Details

415 of 2482 branches covered (16.72%)

Branch coverage included in aggregate %.

52 of 85 new or added lines in 10 files covered. (61.18%)

1 existing line in 1 file now uncovered.

4154 of 6858 relevant lines covered (60.57%)

13.27 hits per line

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

19.57

/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 { 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';

@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,
  ) {
    this.isSwapsDecodingEnabled = this.configurationService.getOrThrow(
      'features.swapsDecoding',
    );
    this.isTwapsDecodingEnabled = this.configurationService.getOrThrow(
      'features.twapsDecoding',
    );
  }

  async mapTransferInfo(
    chainId: string,
    domainTransfer: DomainTransfer,
    safe: Safe,
  ): Promise<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.swapTransferInfoMapper.mapSwapTransferInfo({
          sender,
          recipient,
          direction,
          transferInfo,
          chainId,
          safeAddress: safe.address,
          domainTransfer,
        });

      if (swapTransfer) {
        return swapTransfer;
      }
    }

    return new TransferTransactionInfo(
      sender,
      recipient,
      direction,
      transferInfo,
      null,
      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 { TransferTransactionInfo } from '@/routes/transactions/entities/transfer-transaction-info.entity';	16✔
9	import { Erc20Transfer } from '@/routes/transactions/entities/transfers/erc20-transfer.entity';	16✔
10	import { Erc721Transfer } from '@/routes/transactions/entities/transfers/erc721-transfer.entity';	16✔
11	import { NativeCoinTransfer } from '@/routes/transactions/entities/transfers/native-coin-transfer.entity';	16✔
12	import { getTransferDirection } from '@/routes/transactions/mappers/common/transfer-direction.helper';	16✔
13	import { Transfer } from '@/routes/transactions/entities/transfers/transfer.entity';
14	import { IConfigurationService } from '@/config/configuration.service.interface';	16✔
15	import { SwapTransferInfoMapper } from '@/routes/transactions/mappers/transfers/swap-transfer-info.mapper';	16✔
16
17	@Injectable()
18	export class TransferInfoMapper {	16✔
19	private readonly isSwapsDecodingEnabled: boolean;
20	private readonly isTwapsDecodingEnabled: boolean;
21
22	constructor(
23	@Inject(IConfigurationService)
24	private readonly configurationService: IConfigurationService,	16✔
25	@Inject(ITokenRepository) private readonly tokenRepository: TokenRepository,	16✔
26	private readonly swapTransferInfoMapper: SwapTransferInfoMapper,	16✔
27	private readonly addressInfoHelper: AddressInfoHelper,	16✔
28	) {
29	this.isSwapsDecodingEnabled = this.configurationService.getOrThrow(	16✔
30	'features.swapsDecoding',
31	);
32	this.isTwapsDecodingEnabled = this.configurationService.getOrThrow(	16✔
33	'features.twapsDecoding',
34	);
35	}
36
37	async mapTransferInfo(
38	chainId: string,
39	domainTransfer: DomainTransfer,
40	safe: Safe,
41	): Promise<TransferTransactionInfo> {
42	const { from, to } = domainTransfer;	×
43
NEW 44	const [sender, recipient, transferInfo] = await Promise.all([	×
45	this.addressInfoHelper.getOrDefault(chainId, from, ['TOKEN', 'CONTRACT']),
46	this.addressInfoHelper.getOrDefault(chainId, to, ['TOKEN', 'CONTRACT']),
47	this.getTransferByType(chainId, domainTransfer),
48	]);
49
50	const direction = getTransferDirection(safe.address, from, to);	×
51
NEW 52	if (this.isSwapsDecodingEnabled && this.isTwapsDecodingEnabled) {	×
53	// If the transaction is a swap-based transfer, we return it immediately
54	const swapTransfer =
NEW 55	await this.swapTransferInfoMapper.mapSwapTransferInfo({	×
56	sender,
57	recipient,
58	direction,
59	transferInfo,
60	chainId,
61	safeAddress: safe.address,
62	domainTransfer,
63	});
64
NEW 65	if (swapTransfer) {	×
NEW 66	return swapTransfer;	×
67	}
68	}
69
UNCOV 70	return new TransferTransactionInfo(	×
71	sender,
72	recipient,
73	direction,
74	transferInfo,
75	null,
76	null,
77	);
78	}
79
80	private async getTransferByType(
81	chainId: string,
82	domainTransfer: DomainTransfer,
83	): Promise<Transfer> {
84	if (domainTransfer.type === 'ERC20_TRANSFER') {	×
85	const { tokenAddress, value } = domainTransfer;	×
86	const token: Token \| null = await this.getToken(	×
87	chainId,
88	tokenAddress,
89	).catch(() => null);	×
90	return new Erc20Transfer(	×
91	tokenAddress,
92	value,
93	token?.name,	×
94	token?.symbol,	×
95	token?.logoUri,	×
96	token?.decimals,	×
97	token?.trusted,	×
98	);
99	} else if (domainTransfer.type === 'ERC721_TRANSFER') {	×
100	const { tokenAddress, tokenId } = domainTransfer;	×
101	const token = await this.getToken(chainId, tokenAddress).catch(	×
102	() => null,	×
103	);
104	return new Erc721Transfer(	×
105	tokenAddress,
106	tokenId,
107	token?.name,	×
108	token?.symbol,	×
109	token?.logoUri,	×
110	token?.trusted,	×
111	);
112	} else if (domainTransfer.type === 'ETHER_TRANSFER') {	×
113	return new NativeCoinTransfer(domainTransfer.value);	×
114	} else {
115	throw Error('Unknown transfer type');	×
116	}
117	}
118
119	private getToken(
120	chainId: string,
121	tokenAddress: string \| null,
122	): Promise<Token> {
123	if (!tokenAddress) {	×
124	throw Error('Invalid token address for transfer');	×
125	}
126	return this.tokenRepository.getToken({ chainId, address: tokenAddress });	×
127	}
128	}

safe-global / safe-client-gateway / 9662772307

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