9780922225

Committed 03 Jul 2024 03:43PM UTC coverage: 48.501%. Remained the same

Build # 9780922225

Build Type

push

github

Committed by

web-flow

Commit Message

Revert "Add Swaps decoding debug logs" (#1720)

Revert "Add Swaps decoding debug logs"

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%)

1 existing line in 1 file now uncovered.

4213 of 7001 relevant lines covered (60.18%)

13.13 hits per line

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

17.14

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

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

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

safe-global / safe-client-gateway / 9780922225

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