10112332202

Committed 26 Jul 2024 01:46PM UTC coverage: 48.248% (-0.2%) from 48.454%

Build # 10112332202

Build Type

Pull #1785

github

Committed by

iamacook

Commit Message

Check if final order exists

Pull Request Pull Request #1785: Improve TWAP order mapping with `activeOrderUid`

Run Details

437 of 2661 branches covered (16.42%)

Branch coverage included in aggregate %.

2 of 45 new or added lines in 3 files covered. (4.44%)

2 existing lines in 2 files now uncovered.

4328 of 7215 relevant lines covered (59.99%)

13.01 hits per line

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

15.85

/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 { SwapAppsHelper } from '@/routes/transactions/helpers/swap-apps.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,
    private readonly swapAppsHelper: SwapAppsHelper,
  ) {}

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

    // Decode hash of `appData`
    const fullAppData = await this.swapsRepository.getFullAppData(
      args.chainId,
      twapStruct.appData,
    );

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

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

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

safe-global / safe-client-gateway / 10112332202

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