8892845494

Committed 30 Apr 2024 09:57AM UTC coverage: 92.213% (-0.03%) from 92.238%

Build # 8892845494

Build Type

push

github

Committed by

web-flow

Commit Message

Restrict Swap apps in Confirmation View (#1480)

Adds option to restricts Swap transaction data to certain CoW Swap application

Run Details

1918 of 2347 branches covered (81.72%)

Branch coverage included in aggregate %.

0 of 2 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

6892 of 7207 relevant lines covered (95.63%)

308.36 hits per line

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

17.78

/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.getSwapOrderConfirmationView({
        chainId: args.chainId,
        data: swapOrderData,
        dataDecoded,
      });
    } catch (error) {
      this.loggingService.warn(error);
      return new BaselineConfirmationView({
        method: dataDecoded.method,
        parameters: dataDecoded.parameters,
      });
    }
  }

  private async getSwapOrderConfirmationView(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,
    });

    if (!this.swapOrderHelper.isAppAllowed(order)) {
      throw new Error(`Unsupported App: ${order.fullAppData?.appCode}`);
    }

    return new CowSwapConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      uid: order.uid,
      status: order.status,
      kind: order.kind,
      orderClass: 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,
      receiver: order.receiver,
      owner: order.owner,
      fullAppData: order.fullAppData,
    });
  }
}

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

safe-global / safe-client-gateway / 8892845494

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