8782635164

Committed 22 Apr 2024 10:36AM UTC coverage: 92.262% (-0.4%) from 92.637%

Build # 8782635164

Build Type

Pull #1435

github

Committed by

fmrsabino

Commit Message

Use SetPreSignatureDecoder module

Pull Request Pull Request #1435: Add support for Swap orders in tx confirmation route

Run Details

1925 of 2339 branches covered (82.3%)

Branch coverage included in aggregate %.

36 of 66 new or added lines in 3 files covered. (54.55%)

1 existing line in 1 file now uncovered.

6898 of 7224 relevant lines covered (95.49%)

312.01 hits per line

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

21.62

/src/routes/transactions/transactions-view.service.ts

import { TransactionDataDto } from '@/routes/common/entities/transaction-data.dto.entity';
import {
  BaselineConfirmationView,
  ConfirmationView,
  CowSwapConfirmationView,
} from '@/routes/transactions/entities/confirmation-view/confirmation-view.entity';
import { Inject, Injectable } from '@nestjs/common';
import { IDataDecodedRepository } from '@/domain/data-decoder/data-decoded.repository.interface';
import { SwapOrderHelper } from '@/routes/transactions/helpers/swap-order.helper';
import { SetPreSignatureDecoder } from '@/domain/swaps/contracts/decoders/set-pre-signature-decoder.helper';
import { DataDecoded } from '@/domain/data-decoder/entities/data-decoded.entity';
import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';

@Injectable({})
export class TransactionsViewService {
  constructor(
    @Inject(IDataDecodedRepository)
    private readonly dataDecodedRepository: IDataDecodedRepository,
    private readonly setPreSignatureDecoder: SetPreSignatureDecoder,
    private readonly swapOrderHelper: SwapOrderHelper,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
  ) {}

  async getTransactionConfirmationView(args: {
    chainId: string;
    transactionDataDto: TransactionDataDto;
  }): Promise<ConfirmationView> {
    const dataDecoded = await this.dataDecodedRepository.getDataDecoded({
      chainId: args.chainId,
      data: args.transactionDataDto.data,
      to: args.transactionDataDto.to,
    });

    const swapOrderData = this.swapOrderHelper.findSwapOrder(
      args.transactionDataDto.data,
    );

    if (!swapOrderData) {
      return new BaselineConfirmationView({
        method: dataDecoded.method,
        parameters: dataDecoded.parameters,
      });
    }

    try {
      return await this.handleSwapOrder({
        chainId: args.chainId,
        data: swapOrderData,
        dataDecoded,
      });
    } catch (error) {
      this.loggingService.warn(error);
      return new BaselineConfirmationView({
        method: dataDecoded.method,
        parameters: dataDecoded.parameters,
      });
    }
  }

  private async handleSwapOrder(args: {
    chainId: string;
    data: `0x${string}`;
    dataDecoded: DataDecoded;
  }): Promise<CowSwapConfirmationView> {
    const orderUid: `0x${string}` | null =
      this.setPreSignatureDecoder.getOrderUid(args.data);
    if (!orderUid) {
      throw new Error('Order UID not found in transaction data');
    }

    const { order, sellToken, buyToken } = await this.swapOrderHelper.getOrder({
      chainId: args.chainId,
      orderUid,
    });

    return new CowSwapConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      uid: order.uid,
      status: 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(),
      explorerUrl: this.swapOrderHelper.getOrderExplorerUrl(order),
      sellToken: new TokenInfo({
        address: sellToken.address,
        decimals: sellToken.decimals,
        logoUri: sellToken.logoUri,
        name: sellToken.name,
        symbol: sellToken.symbol,
        trusted: sellToken.trusted,
      }),
      buyToken: new TokenInfo({
        address: buyToken.address,
        decimals: buyToken.decimals,
        logoUri: buyToken.logoUri,
        name: buyToken.name,
        symbol: buyToken.symbol,
        trusted: buyToken.trusted,
      }),
      executedSurplusFee: order.executedSurplusFee?.toString() ?? null,
    });
  }
}

1	import { TransactionDataDto } from '@/routes/common/entities/transaction-data.dto.entity';
2	import {	92✔
3	BaselineConfirmationView,
4	ConfirmationView,
5	CowSwapConfirmationView,
6	} from '@/routes/transactions/entities/confirmation-view/confirmation-view.entity';
7	import { Inject, Injectable } from '@nestjs/common';	92✔
8	import { IDataDecodedRepository } from '@/domain/data-decoder/data-decoded.repository.interface';	92✔
9	import { SwapOrderHelper } from '@/routes/transactions/helpers/swap-order.helper';	92✔
10	import { SetPreSignatureDecoder } from '@/domain/swaps/contracts/decoders/set-pre-signature-decoder.helper';	92✔
11	import { DataDecoded } from '@/domain/data-decoder/entities/data-decoded.entity';
12	import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';	92✔
13	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	92✔
14
15	@Injectable({})
16	export class TransactionsViewService {	92✔
17	constructor(
18	@Inject(IDataDecodedRepository)
19	private readonly dataDecodedRepository: IDataDecodedRepository,	×
NEW 20	private readonly setPreSignatureDecoder: SetPreSignatureDecoder,	×
NEW 21	private readonly swapOrderHelper: SwapOrderHelper,	×
NEW 22	@Inject(LoggingService) private readonly loggingService: ILoggingService,	×
23	) {}
24
25	async getTransactionConfirmationView(args: {
26	chainId: string;
27	transactionDataDto: TransactionDataDto;
28	}): Promise<ConfirmationView> {
29	const dataDecoded = await this.dataDecodedRepository.getDataDecoded({	×
30	chainId: args.chainId,
31	data: args.transactionDataDto.data,
32	to: args.transactionDataDto.to,
33	});
34
NEW 35	const swapOrderData = this.swapOrderHelper.findSwapOrder(	×
36	args.transactionDataDto.data,
37	);
38
NEW 39	if (!swapOrderData) {	×
NEW 40	return new BaselineConfirmationView({	×
41	method: dataDecoded.method,
42	parameters: dataDecoded.parameters,
43	});
44	}
45
NEW 46	try {	×
NEW 47	return await this.handleSwapOrder({	×
48	chainId: args.chainId,
49	data: swapOrderData,
50	dataDecoded,
51	});
52	} catch (error) {
NEW 53	this.loggingService.warn(error);	×
NEW 54	return new BaselineConfirmationView({	×
55	method: dataDecoded.method,
56	parameters: dataDecoded.parameters,
57	});
58	}
59	}
60
61	private async handleSwapOrder(args: {
62	chainId: string;
63	data: `0x${string}`;
64	dataDecoded: DataDecoded;
65	}): Promise<CowSwapConfirmationView> {
66	const orderUid: `0x${string}` \| null =
NEW 67	this.setPreSignatureDecoder.getOrderUid(args.data);	×
NEW 68	if (!orderUid) {	×
NEW 69	throw new Error('Order UID not found in transaction data');	×
70	}
71
NEW 72	const { order, sellToken, buyToken } = await this.swapOrderHelper.getOrder({	×
73	chainId: args.chainId,
74	orderUid,
75	});
76
NEW 77	return new CowSwapConfirmationView({	×
78	method: args.dataDecoded.method,
79	parameters: args.dataDecoded.parameters,
80	uid: order.uid,
81	status: order.status,
82	kind: order.kind,
83	class: order.class,
84	validUntil: order.validTo,
85	sellAmount: order.sellAmount.toString(),
86	buyAmount: order.buyAmount.toString(),
87	executedSellAmount: order.executedSellAmount.toString(),
88	executedBuyAmount: order.executedBuyAmount.toString(),
89	explorerUrl: this.swapOrderHelper.getOrderExplorerUrl(order),
90	sellToken: new TokenInfo({
91	address: sellToken.address,
92	decimals: sellToken.decimals,
93	logoUri: sellToken.logoUri,
94	name: sellToken.name,
95	symbol: sellToken.symbol,
96	trusted: sellToken.trusted,
97	}),
98	buyToken: new TokenInfo({
99	address: buyToken.address,
100	decimals: buyToken.decimals,
101	logoUri: buyToken.logoUri,
102	name: buyToken.name,
103	symbol: buyToken.symbol,
104	trusted: buyToken.trusted,
105	}),
106	executedSurplusFee: order.executedSurplusFee?.toString() ?? null,	×
107	});
108	}
109	}

safe-global / safe-client-gateway / 8782635164

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