9806327775

Committed 05 Jul 2024 09:40AM UTC coverage: 48.266% (-0.3%) from 48.517%

Build # 9806327775

Build Type

push

github

Committed by

web-flow

Commit Message

Filter out TWAP orders from not allowed apps (#1698)

Add TwapOrderHelper.isAppAllowed

Run Details

412 of 2587 branches covered (15.93%)

Branch coverage included in aggregate %.

8 of 30 new or added lines in 5 files covered. (26.67%)

3 existing lines in 3 files now uncovered.

4223 of 7016 relevant lines covered (60.19%)

13.13 hits per line

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

15.0

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

    // TODO: Refactor with confirmation view, swaps and TWAPs
    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,
    });

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

    // TODO: Refactor with confirmation view, swaps and TWAPs
    if (!this.twapOrderHelper.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,
      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
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) {
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	// TODO: Refactor with confirmation view, swaps and TWAPs
107	if (!this.swapOrderHelper.isAppAllowed(order)) {	×
108	throw new Error(`Unsupported App: ${order.fullAppData?.appCode}`);	×
109	}
110
111	const [sellToken, buyToken] = await Promise.all([	×
112	this.swapOrderHelper.getToken({
113	chainId: args.chainId,
114	address: order.sellToken,
115	}),
116	this.swapOrderHelper.getToken({
117	chainId: args.chainId,
118	address: order.buyToken,
119	}),
120	]);
121
122	return new CowSwapConfirmationView({	×
123	method: args.dataDecoded.method,
124	parameters: args.dataDecoded.parameters,
125	uid: order.uid,
126	status: order.status,
127	kind: order.kind,
128	orderClass: order.class,
129	validUntil: order.validTo,
130	sellAmount: order.sellAmount.toString(),
131	buyAmount: order.buyAmount.toString(),
132	executedSellAmount: order.executedSellAmount.toString(),
133	executedBuyAmount: order.executedBuyAmount.toString(),
134	explorerUrl: this.swapOrderHelper.getOrderExplorerUrl(order).toString(),
135	sellToken: new TokenInfo({
136	address: sellToken.address,
137	decimals: sellToken.decimals,
138	logoUri: sellToken.logoUri,
139	name: sellToken.name,
140	symbol: sellToken.symbol,
141	trusted: sellToken.trusted,
142	}),
143	buyToken: new TokenInfo({
144	address: buyToken.address,
145	decimals: buyToken.decimals,
146	logoUri: buyToken.logoUri,
147	name: buyToken.name,
148	symbol: buyToken.symbol,
149	trusted: buyToken.trusted,
150	}),
151	executedSurplusFee: order.executedSurplusFee?.toString() ?? null,	×
152	receiver: order.receiver,
153	owner: order.owner,
154	fullAppData: order.fullAppData,
155	});
156	}
157
158	private async getTwapOrderConfirmationView(args: {
159	chainId: string;
160	safeAddress: `0x${string}`;
161	data: `0x${string}`;
162	dataDecoded: DataDecoded;
163	}): Promise<CowSwapTwapConfirmationView> {
164	// Decode `staticInput` of `createWithContextCall`
165	const twapStruct = this.composableCowDecoder.decodeTwapStruct(args.data);	×
166	const twapOrderData =
167	this.twapOrderHelper.twapStructToPartialOrderInfo(twapStruct);	×
168
169	// Generate parts of the TWAP order
170	const twapParts = this.twapOrderHelper.generateTwapOrderParts({	×
171	twapStruct,
172	executionDate: new Date(),
173	chainId: args.chainId,
174	});
175
176	// Decode hash of `appData`
NEW 177	const fullAppData = await this.swapsRepository.getFullAppData(	×
178	args.chainId,
179	twapStruct.appData,
180	);
181
182	// TODO: Refactor with confirmation view, swaps and TWAPs
NEW 183	if (!this.twapOrderHelper.isAppAllowed(fullAppData)) {	×
NEW 184	throw new Error(`Unsupported App: ${fullAppData.fullAppData?.appCode}`);	×
185	}
186
NEW 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
UNCOV 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	validUntil: Math.max(...twapParts.map((order) => order.validTo)),	×
205	sellAmount: twapOrderData.sellAmount,
206	buyAmount: twapOrderData.buyAmount,
207	executedSellAmount: '0',
208	executedBuyAmount: '0',
209	executedSurplusFee: '0',
210	sellToken: new TokenInfo({
211	address: sellToken.address,
212	decimals: sellToken.decimals,
213	logoUri: sellToken.logoUri,
214	name: sellToken.name,
215	symbol: sellToken.symbol,
216	trusted: sellToken.trusted,
217	}),
218	buyToken: new TokenInfo({
219	address: buyToken.address,
220	decimals: buyToken.decimals,
221	logoUri: buyToken.logoUri,
222	name: buyToken.name,
223	symbol: buyToken.symbol,
224	trusted: buyToken.trusted,
225	}),
226	receiver: twapStruct.receiver,
227	owner: args.safeAddress,
228	fullAppData: fullAppData.fullAppData,
229	numberOfParts: twapOrderData.numberOfParts,
230	partSellAmount: twapStruct.partSellAmount.toString(),
231	minPartLimit: twapStruct.minPartLimit.toString(),
232	timeBetweenParts: twapOrderData.timeBetweenParts,
233	durationOfPart: twapOrderData.durationOfPart,
234	startTime: twapOrderData.startTime,
235	});
236	}
237	}

safe-global / safe-client-gateway / 9806327775

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