9780779066

Committed 03 Jul 2024 03:32PM UTC coverage: 48.501% (+0.04%) from 48.461%

Build # 9780779066

Build Type

push

github

Committed by

hectorgomezv

Commit Message

Revert "Add Swaps decoding debug logs"

This reverts commit c0ad06a8b.

Run Details

414 of 2539 branches covered (16.31%)

Branch coverage included in aggregate %.

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

2 existing lines in 2 files now uncovered.

4214 of 7003 relevant lines covered (60.17%)

13.14 hits per line

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

18.06

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

import { TransactionDataDto } from '@/routes/common/entities/transaction-data.dto.entity';
import {
  BaselineConfirmationView,
  ConfirmationView,
  CowSwapConfirmationView,
  CowSwapTwapConfirmationView,
} 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 { GPv2Decoder } from '@/domain/swaps/contracts/decoders/gp-v2-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';
import { TwapOrderHelper } from '@/routes/transactions/helpers/twap-order.helper';
import { OrderStatus } from '@/domain/swaps/entities/order.entity';
import { ISwapsRepository } from '@/domain/swaps/swaps.repository';
import { ComposableCowDecoder } from '@/domain/swaps/contracts/decoders/composable-cow-decoder.helper';
import { asError } from '@/logging/utils';

@Injectable({})
export class TransactionsViewService {
  constructor(
    @Inject(IDataDecodedRepository)
    private readonly dataDecodedRepository: IDataDecodedRepository,
    private readonly gpv2Decoder: GPv2Decoder,
    private readonly swapOrderHelper: SwapOrderHelper,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    private readonly twapOrderHelper: TwapOrderHelper,
    @Inject(ISwapsRepository)
    private readonly swapsRepository: ISwapsRepository,
    private readonly composableCowDecoder: ComposableCowDecoder,
  ) {}

  async getTransactionConfirmationView(args: {
    chainId: string;
    safeAddress: `0x${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,
    );

    const twapSwapOrderData = args.transactionDataDto.to
      ? this.twapOrderHelper.findTwapOrder({
          to: args.transactionDataDto.to,
          data: args.transactionDataDto.data,
        })
      : null;

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

    try {
      if (swapOrderData) {
        return await this.getSwapOrderConfirmationView({
          chainId: args.chainId,
          data: swapOrderData,
          dataDecoded,
        });
      } else if (twapSwapOrderData) {
        return await this.getTwapOrderConfirmationView({
          chainId: args.chainId,
          safeAddress: args.safeAddress,
          data: twapSwapOrderData,
          dataDecoded,
        });
      } else {
        // Should not reach here
        throw new Error('No swap order data found');
      }
    } catch (error) {
      this.loggingService.warn(asError(error).message);
      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.gpv2Decoder.getOrderUidFromSetPreSignature(args.data);
    if (!orderUid) {
      throw new Error('Order UID not found in transaction data');
    }

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

    this.loggingService.info(JSON.stringify(order.kind));

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

    const [sellToken, buyToken] = await Promise.all([
      this.swapOrderHelper.getToken({
        chainId: args.chainId,
        address: order.sellToken,
      }),
      this.swapOrderHelper.getToken({
        chainId: args.chainId,
        address: order.buyToken,
      }),
    ]);

    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).toString(),
      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,
    });
  }

  private async getTwapOrderConfirmationView(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    data: `0x${string}`;
    dataDecoded: DataDecoded;
  }): Promise<CowSwapTwapConfirmationView> {
    // Decode `staticInput` of `createWithContextCall`
    const twapStruct = this.composableCowDecoder.decodeTwapStruct(args.data);
    const twapOrderData =
      this.twapOrderHelper.twapStructToPartialOrderInfo(twapStruct);

    // Generate parts of the TWAP order
    const twapParts = this.twapOrderHelper.generateTwapOrderParts({
      twapStruct,
      executionDate: new Date(),
      chainId: args.chainId,
    });

    const [{ fullAppData }, buyToken, sellToken] = await Promise.all([
      // Decode hash of `appData`
      this.swapsRepository.getFullAppData(args.chainId, twapStruct.appData),
      this.swapOrderHelper.getToken({
        chainId: args.chainId,
        address: twapStruct.buyToken,
      }),
      this.swapOrderHelper.getToken({
        chainId: args.chainId,
        address: twapStruct.sellToken,
      }),
    ]);

    // TODO: Handling of restricted Apps

    return new CowSwapTwapConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      status: OrderStatus.PreSignaturePending,
      kind: twapOrderData.kind,
      class: twapOrderData.class,
      validUntil: Math.max(...twapParts.map((order) => order.validTo)),
      sellAmount: twapOrderData.sellAmount,
      buyAmount: twapOrderData.buyAmount,
      executedSellAmount: '0',
      executedBuyAmount: '0',
      executedSurplusFee: '0',
      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,
      }),
      receiver: twapStruct.receiver,
      owner: args.safeAddress,
      fullAppData,
      numberOfParts: twapOrderData.numberOfParts,
      partSellAmount: twapStruct.partSellAmount.toString(),
      minPartLimit: twapStruct.minPartLimit.toString(),
      timeBetweenParts: twapOrderData.timeBetweenParts,
      durationOfPart: twapOrderData.durationOfPart,
      startTime: twapOrderData.startTime,
    });
  }
}

1	import { TransactionDataDto } from '@/routes/common/entities/transaction-data.dto.entity';
2	import {	16✔
3	BaselineConfirmationView,
4	ConfirmationView,
5	CowSwapConfirmationView,
6	CowSwapTwapConfirmationView,
7	} from '@/routes/transactions/entities/confirmation-view/confirmation-view.entity';
8	import { Inject, Injectable } from '@nestjs/common';	16✔
9	import { IDataDecodedRepository } from '@/domain/data-decoder/data-decoded.repository.interface';	16✔
10	import { SwapOrderHelper } from '@/routes/transactions/helpers/swap-order.helper';	16✔
11	import { GPv2Decoder } from '@/domain/swaps/contracts/decoders/gp-v2-decoder.helper';	16✔
12	import { DataDecoded } from '@/domain/data-decoder/entities/data-decoded.entity';
13	import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';	16✔
14	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	16✔
15	import { TwapOrderHelper } from '@/routes/transactions/helpers/twap-order.helper';	16✔
16	import { OrderStatus } from '@/domain/swaps/entities/order.entity';	16✔
17	import { ISwapsRepository } from '@/domain/swaps/swaps.repository';	16✔
18	import { ComposableCowDecoder } from '@/domain/swaps/contracts/decoders/composable-cow-decoder.helper';	16✔
19	import { asError } from '@/logging/utils';	16✔
20
21	@Injectable({})
22	export class TransactionsViewService {	16✔
23	constructor(
24	@Inject(IDataDecodedRepository)
25	private readonly dataDecodedRepository: IDataDecodedRepository,	×
26	private readonly gpv2Decoder: GPv2Decoder,	×
27	private readonly swapOrderHelper: SwapOrderHelper,	×
28	@Inject(LoggingService) private readonly loggingService: ILoggingService,	×
29	private readonly twapOrderHelper: TwapOrderHelper,	×
30	@Inject(ISwapsRepository)
31	private readonly swapsRepository: ISwapsRepository,	×
32	private readonly composableCowDecoder: ComposableCowDecoder,	×
33	) {}
34
35	async getTransactionConfirmationView(args: {
36	chainId: string;
37	safeAddress: `0x${string}`;
38	transactionDataDto: TransactionDataDto;
39	}): Promise<ConfirmationView> {
40	const dataDecoded = await this.dataDecodedRepository.getDataDecoded({	×
41	chainId: args.chainId,
42	data: args.transactionDataDto.data,
43	to: args.transactionDataDto.to,
44	});
45
46	const swapOrderData = this.swapOrderHelper.findSwapOrder(	×
47	args.transactionDataDto.data,
48	);
49
50	const twapSwapOrderData = args.transactionDataDto.to	×
51	? this.twapOrderHelper.findTwapOrder({
52	to: args.transactionDataDto.to,
53	data: args.transactionDataDto.data,
54	})
55	: null;
56
57	if (!swapOrderData && !twapSwapOrderData) {	×
58	return new BaselineConfirmationView({	×
59	method: dataDecoded.method,
60	parameters: dataDecoded.parameters,
61	});
62	}
63
64	try {	×
65	if (swapOrderData) {	×
66	return await this.getSwapOrderConfirmationView({	×
67	chainId: args.chainId,
68	data: swapOrderData,
69	dataDecoded,
70	});
71	} else if (twapSwapOrderData) {	×
72	return await this.getTwapOrderConfirmationView({	×
73	chainId: args.chainId,
74	safeAddress: args.safeAddress,
75	data: twapSwapOrderData,
76	dataDecoded,
77	});
78	} else {
79	// Should not reach here
80	throw new Error('No swap order data found');	×
81	}
82	} catch (error) {
83	this.loggingService.warn(asError(error).message);	×
84	return new BaselineConfirmationView({	×
85	method: dataDecoded.method,
86	parameters: dataDecoded.parameters,
87	});
88	}
89	}
90
91	private async getSwapOrderConfirmationView(args: {
92	chainId: string;
93	data: `0x${string}`;
94	dataDecoded: DataDecoded;
95	}): Promise<CowSwapConfirmationView> {
96	const orderUid: `0x${string}` \| null =
UNCOV 97	this.gpv2Decoder.getOrderUidFromSetPreSignature(args.data);	×
98	if (!orderUid) {	×
99	throw new Error('Order UID not found in transaction data');	×
100	}
101
102	const order = await this.swapOrderHelper.getOrder({	×
103	chainId: args.chainId,
104	orderUid,
105	});
106
107	this.loggingService.info(JSON.stringify(order.kind));	×
108
109	if (!this.swapOrderHelper.isAppAllowed(order)) {	×
110	throw new Error(`Unsupported App: ${order.fullAppData?.appCode}`);	×
111	}
112
113	const [sellToken, buyToken] = await Promise.all([	×
114	this.swapOrderHelper.getToken({
115	chainId: args.chainId,
116	address: order.sellToken,
117	}),
118	this.swapOrderHelper.getToken({
119	chainId: args.chainId,
120	address: order.buyToken,
121	}),
122	]);
123
124	return new CowSwapConfirmationView({	×
125	method: args.dataDecoded.method,
126	parameters: args.dataDecoded.parameters,
127	uid: order.uid,
128	status: order.status,
129	kind: order.kind,
130	orderClass: order.class,
131	validUntil: order.validTo,
132	sellAmount: order.sellAmount.toString(),
133	buyAmount: order.buyAmount.toString(),
134	executedSellAmount: order.executedSellAmount.toString(),
135	executedBuyAmount: order.executedBuyAmount.toString(),
136	explorerUrl: this.swapOrderHelper.getOrderExplorerUrl(order).toString(),
137	sellToken: new TokenInfo({
138	address: sellToken.address,
139	decimals: sellToken.decimals,
140	logoUri: sellToken.logoUri,
141	name: sellToken.name,
142	symbol: sellToken.symbol,
143	trusted: sellToken.trusted,
144	}),
145	buyToken: new TokenInfo({
146	address: buyToken.address,
147	decimals: buyToken.decimals,
148	logoUri: buyToken.logoUri,
149	name: buyToken.name,
150	symbol: buyToken.symbol,
151	trusted: buyToken.trusted,
152	}),
153	executedSurplusFee: order.executedSurplusFee?.toString() ?? null,	×
154	receiver: order.receiver,
155	owner: order.owner,
156	fullAppData: order.fullAppData,
157	});
158	}
159
160	private async getTwapOrderConfirmationView(args: {
161	chainId: string;
162	safeAddress: `0x${string}`;
163	data: `0x${string}`;
164	dataDecoded: DataDecoded;
165	}): Promise<CowSwapTwapConfirmationView> {
166	// Decode `staticInput` of `createWithContextCall`
167	const twapStruct = this.composableCowDecoder.decodeTwapStruct(args.data);	×
168	const twapOrderData =
169	this.twapOrderHelper.twapStructToPartialOrderInfo(twapStruct);	×
170
171	// Generate parts of the TWAP order
172	const twapParts = this.twapOrderHelper.generateTwapOrderParts({	×
173	twapStruct,
174	executionDate: new Date(),
175	chainId: args.chainId,
176	});
177
178	const [{ fullAppData }, buyToken, sellToken] = await Promise.all([	×
179	// Decode hash of `appData`
180	this.swapsRepository.getFullAppData(args.chainId, twapStruct.appData),
181	this.swapOrderHelper.getToken({
182	chainId: args.chainId,
183	address: twapStruct.buyToken,
184	}),
185	this.swapOrderHelper.getToken({
186	chainId: args.chainId,
187	address: twapStruct.sellToken,
188	}),
189	]);
190
191	// TODO: Handling of restricted Apps
192
193	return new CowSwapTwapConfirmationView({	×
194	method: args.dataDecoded.method,
195	parameters: args.dataDecoded.parameters,
196	status: OrderStatus.PreSignaturePending,
197	kind: twapOrderData.kind,
198	class: twapOrderData.class,
199	validUntil: Math.max(...twapParts.map((order) => order.validTo)),	×
200	sellAmount: twapOrderData.sellAmount,
201	buyAmount: twapOrderData.buyAmount,
202	executedSellAmount: '0',
203	executedBuyAmount: '0',
204	executedSurplusFee: '0',
205	sellToken: new TokenInfo({
206	address: sellToken.address,
207	decimals: sellToken.decimals,
208	logoUri: sellToken.logoUri,
209	name: sellToken.name,
210	symbol: sellToken.symbol,
211	trusted: sellToken.trusted,
212	}),
213	buyToken: new TokenInfo({
214	address: buyToken.address,
215	decimals: buyToken.decimals,
216	logoUri: buyToken.logoUri,
217	name: buyToken.name,
218	symbol: buyToken.symbol,
219	trusted: buyToken.trusted,
220	}),
221	receiver: twapStruct.receiver,
222	owner: args.safeAddress,
223	fullAppData,
224	numberOfParts: twapOrderData.numberOfParts,
225	partSellAmount: twapStruct.partSellAmount.toString(),
226	minPartLimit: twapStruct.minPartLimit.toString(),
227	timeBetweenParts: twapOrderData.timeBetweenParts,
228	durationOfPart: twapOrderData.durationOfPart,
229	startTime: twapOrderData.startTime,
230	});
231	}
232	}

safe-global / safe-client-gateway / 9780779066

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