9784936466

Committed 03 Jul 2024 09:16PM UTC coverage: 48.376% (-0.1%) from 48.501%

Build # 9784936466

Build Type

Pull #1698

github

Committed by

hectorgomezv

Commit Message

Remove useless catch block

Pull Request Pull Request #1698: Filter out TWAP orders from not allowed apps

Run Details

414 of 2562 branches covered (16.16%)

Branch coverage included in aggregate %.

7 of 17 new or added lines in 3 files covered. (41.18%)

1 existing line in 1 file now uncovered.

4219 of 7015 relevant lines covered (60.14%)

13.12 hits per line

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

22.55

/src/routes/transactions/mappers/common/twap-order.mapper.ts

import { Inject, Injectable, Module } from '@nestjs/common';
import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';
import {
  SwapOrderHelper,
  SwapOrderHelperModule,
} from '@/routes/transactions/helpers/swap-order.helper';
import { ComposableCowDecoder } from '@/domain/swaps/contracts/decoders/composable-cow-decoder.helper';
import {
  TwapOrderInfo,
  TwapOrderTransactionInfo,
} from '@/routes/transactions/entities/swaps/twap-order-info.entity';
import {
  TwapOrderHelper,
  TwapOrderHelperModule,
} from '@/routes/transactions/helpers/twap-order.helper';
import {
  KnownOrder,
  OrderKind,
  OrderStatus,
} from '@/domain/swaps/entities/order.entity';
import { ISwapsRepository } from '@/domain/swaps/swaps.repository';
import { SwapsRepositoryModule } from '@/domain/swaps/swaps-repository.module';
import { SwapOrderMapperModule } from '@/routes/transactions/mappers/common/swap-order.mapper';
import { GPv2OrderHelper } from '@/routes/transactions/helpers/gp-v2-order.helper';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';

@Injectable()
export class TwapOrderMapper {
  private maxNumberOfParts: number;

  constructor(
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    private readonly swapOrderHelper: SwapOrderHelper,
    @Inject(ISwapsRepository)
    private readonly swapsRepository: ISwapsRepository,
    private readonly composableCowDecoder: ComposableCowDecoder,
    private readonly gpv2OrderHelper: GPv2OrderHelper,
    private readonly twapOrderHelper: TwapOrderHelper,
  ) {
    this.maxNumberOfParts = this.configurationService.getOrThrow(
      'swaps.maxNumberOfParts',
    );
  }

  /**
   * Maps a TWAP order from a given transaction
   *
   * @param chainId - chain the order is on
   * @param safeAddress - "owner" of the order
   * @param transaction - transaction data and execution date
   * @returns mapped {@link TwapOrderTransactionInfo}
   */
  async mapTwapOrder(
    chainId: string,
    safeAddress: `0x${string}`,
    transaction: { data: `0x${string}`; executionDate: Date | null },
  ): Promise<TwapOrderTransactionInfo> {
    // Decode `staticInput` of `createWithContextCall`
    const twapStruct = this.composableCowDecoder.decodeTwapStruct(
      transaction.data,
    );
    const twapOrderData =
      this.twapOrderHelper.twapStructToPartialOrderInfo(twapStruct);

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

    // There can be up to uint256 parts in a TWAP order so we limit this
    // to avoid requesting too many orders
    const hasAbundantParts = twapParts.length > this.maxNumberOfParts;

    // Fetch all order parts if the transaction has been executed, otherwise none
    const partsToFetch = transaction.executionDate
      ? hasAbundantParts
        ? // We use the last part (and only one) to get the status of the entire
          // order and we only need one to get the token info
          twapParts.slice(-1)
        : twapParts
      : [];

    const fullAppData = await this.swapsRepository.getFullAppData(
      chainId,
      twapStruct.appData,
    );

    const orders: Array<KnownOrder> = [];

    for (const part of partsToFetch) {
      const orderUid = this.gpv2OrderHelper.computeOrderUid({
        chainId,
        owner: safeAddress,
        order: part,
      });

      try {
        const order = await this.swapsRepository.getOrder(chainId, orderUid);
        if (order.kind === OrderKind.Buy || order.kind === OrderKind.Sell) {
          orders.push(order as KnownOrder);
        }
      } catch (err) {
        this.loggingService.warn(
          `Error getting orderUid ${orderUid} from SwapsRepository`,
        );
      }
    }

    if (!this.twapOrderHelper.isAppAllowed(fullAppData)) {
      throw new Error(`Unsupported App: ${fullAppData.fullAppData?.appCode}`);
    }
    // TODO: Calling `getToken` directly instead of multiple times in `getOrder` for sellToken and buyToken

    const executedSellAmount: TwapOrderInfo['executedSellAmount'] =
      hasAbundantParts ? null : this.getExecutedSellAmount(orders).toString();

    const executedBuyAmount: TwapOrderInfo['executedBuyAmount'] =
      hasAbundantParts ? null : this.getExecutedBuyAmount(orders).toString();

    const executedSurplusFee: TwapOrderInfo['executedSurplusFee'] =
      hasAbundantParts ? null : this.getExecutedSurplusFee(orders).toString();

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

    return new TwapOrderTransactionInfo({
      status: this.getOrderStatus(orders),
      kind: twapOrderData.kind,
      class: twapOrderData.class,
      validUntil: Math.max(...twapParts.map((order) => order.validTo)),
      sellAmount: twapOrderData.sellAmount,
      buyAmount: twapOrderData.buyAmount,
      executedSellAmount,
      executedBuyAmount,
      executedSurplusFee,
      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: safeAddress,
      fullAppData: fullAppData.fullAppData,
      numberOfParts: twapOrderData.numberOfParts,
      partSellAmount: twapStruct.partSellAmount.toString(),
      minPartLimit: twapStruct.minPartLimit.toString(),
      timeBetweenParts: twapOrderData.timeBetweenParts,
      durationOfPart: twapOrderData.durationOfPart,
      startTime: twapOrderData.startTime,
    });
  }

  private getOrderStatus(
    orders: Array<Awaited<ReturnType<typeof this.swapOrderHelper.getOrder>>>,
  ): OrderStatus {
    if (orders.length === 0) {
      return OrderStatus.PreSignaturePending;
    }

    // If an order is fulfilled, cancelled or expired, the part is "complete"
    const completeStatuses = [
      OrderStatus.Fulfilled,
      OrderStatus.Cancelled,
      OrderStatus.Expired,
    ];

    for (let i = 0; i < orders.length; i++) {
      const order = orders[i];

      // Return the status of the last part
      if (i === orders.length - 1) {
        return order.status;
      }

      // If the part is complete, continue to the next part
      if (completeStatuses.includes(order.status)) {
        continue;
      }

      return order.status;
    }

    return OrderStatus.Unknown;
  }

  private getExecutedSellAmount(orders: Array<KnownOrder>): bigint {
    return orders.reduce((acc, order) => {
      return acc + BigInt(order.executedSellAmount);
    }, BigInt(0));
  }

  private getExecutedBuyAmount(orders: Array<KnownOrder>): bigint {
    return orders.reduce((acc, order) => {
      return acc + BigInt(order.executedBuyAmount);
    }, BigInt(0));
  }

  private getExecutedSurplusFee(orders: Array<KnownOrder>): bigint {
    return orders.reduce((acc, order) => {
      return acc + BigInt(order.executedSurplusFee ?? BigInt(0));
    }, BigInt(0));
  }
}

@Module({
  imports: [
    SwapOrderHelperModule,
    SwapsRepositoryModule,
    SwapOrderMapperModule,
    TwapOrderHelperModule,
  ],
  providers: [ComposableCowDecoder, GPv2OrderHelper, TwapOrderMapper],
  exports: [TwapOrderMapper],
})
export class TwapOrderMapperModule {}

1	import { Inject, Injectable, Module } from '@nestjs/common';	16✔
2	import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';	16✔
3	import {	16✔
4	SwapOrderHelper,
5	SwapOrderHelperModule,
6	} from '@/routes/transactions/helpers/swap-order.helper';
7	import { ComposableCowDecoder } from '@/domain/swaps/contracts/decoders/composable-cow-decoder.helper';	16✔
8	import {	16✔
9	TwapOrderInfo,
10	TwapOrderTransactionInfo,
11	} from '@/routes/transactions/entities/swaps/twap-order-info.entity';
12	import {	16✔
13	TwapOrderHelper,
14	TwapOrderHelperModule,
15	} from '@/routes/transactions/helpers/twap-order.helper';
16	import {	16✔
17	KnownOrder,
18	OrderKind,
19	OrderStatus,
20	} from '@/domain/swaps/entities/order.entity';
21	import { ISwapsRepository } from '@/domain/swaps/swaps.repository';	16✔
22	import { SwapsRepositoryModule } from '@/domain/swaps/swaps-repository.module';	16✔
23	import { SwapOrderMapperModule } from '@/routes/transactions/mappers/common/swap-order.mapper';	16✔
24	import { GPv2OrderHelper } from '@/routes/transactions/helpers/gp-v2-order.helper';	16✔
25	import { IConfigurationService } from '@/config/configuration.service.interface';	16✔
26	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	16✔
27
28	@Injectable()
29	export class TwapOrderMapper {	16✔
30	private maxNumberOfParts: number;
31
32	constructor(
33	@Inject(IConfigurationService)
34	private readonly configurationService: IConfigurationService,	16✔
35	@Inject(LoggingService) private readonly loggingService: ILoggingService,	16✔
36	private readonly swapOrderHelper: SwapOrderHelper,	16✔
37	@Inject(ISwapsRepository)
38	private readonly swapsRepository: ISwapsRepository,	16✔
39	private readonly composableCowDecoder: ComposableCowDecoder,	16✔
40	private readonly gpv2OrderHelper: GPv2OrderHelper,	16✔
41	private readonly twapOrderHelper: TwapOrderHelper,	16✔
42	) {
43	this.maxNumberOfParts = this.configurationService.getOrThrow(	16✔
44	'swaps.maxNumberOfParts',
45	);
46	}
47
48	/**
49	* Maps a TWAP order from a given transaction
50	*
51	* @param chainId - chain the order is on
52	* @param safeAddress - "owner" of the order
53	* @param transaction - transaction data and execution date
54	* @returns mapped {@link TwapOrderTransactionInfo}
55	*/
56	async mapTwapOrder(
57	chainId: string,
58	safeAddress: `0x${string}`,
59	transaction: { data: `0x${string}`; executionDate: Date \| null },
60	): Promise<TwapOrderTransactionInfo> {
61	// Decode `staticInput` of `createWithContextCall`
62	const twapStruct = this.composableCowDecoder.decodeTwapStruct(	×
63	transaction.data,
64	);
65	const twapOrderData =
66	this.twapOrderHelper.twapStructToPartialOrderInfo(twapStruct);	×
67
68	// Generate parts of the TWAP order
69	const twapParts = this.twapOrderHelper.generateTwapOrderParts({	×
70	twapStruct,
71	executionDate: transaction.executionDate ?? new Date(),	×
72	chainId,
73	});
74
75	// There can be up to uint256 parts in a TWAP order so we limit this
76	// to avoid requesting too many orders
77	const hasAbundantParts = twapParts.length > this.maxNumberOfParts;	×
78
79	// Fetch all order parts if the transaction has been executed, otherwise none
80	const partsToFetch = transaction.executionDate	×
81	? hasAbundantParts	×
82	? // We use the last part (and only one) to get the status of the entire
83	// order and we only need one to get the token info
84	twapParts.slice(-1)
85	: twapParts
86	: [];
87
NEW 88	const fullAppData = await this.swapsRepository.getFullAppData(	×
89	chainId,
90	twapStruct.appData,
91	);
92
93	const orders: Array<KnownOrder> = [];	×
94
95	for (const part of partsToFetch) {	×
96	const orderUid = this.gpv2OrderHelper.computeOrderUid({	×
97	chainId,
98	owner: safeAddress,
99	order: part,
100	});
101
102	try {	×
103	const order = await this.swapsRepository.getOrder(chainId, orderUid);	×
104	if (order.kind === OrderKind.Buy \|\| order.kind === OrderKind.Sell) {	×
105	orders.push(order as KnownOrder);	×
106	}
107	} catch (err) {
108	this.loggingService.warn(	×
109	`Error getting orderUid ${orderUid} from SwapsRepository`,
110	);
111	}
112	}
113
NEW 114	if (!this.twapOrderHelper.isAppAllowed(fullAppData)) {	×
NEW 115	throw new Error(`Unsupported App: ${fullAppData.fullAppData?.appCode}`);	×
116	}
117	// TODO: Calling `getToken` directly instead of multiple times in `getOrder` for sellToken and buyToken
118
119	const executedSellAmount: TwapOrderInfo['executedSellAmount'] =
120	hasAbundantParts ? null : this.getExecutedSellAmount(orders).toString();	×
121
122	const executedBuyAmount: TwapOrderInfo['executedBuyAmount'] =
123	hasAbundantParts ? null : this.getExecutedBuyAmount(orders).toString();	×
124
125	const executedSurplusFee: TwapOrderInfo['executedSurplusFee'] =
126	hasAbundantParts ? null : this.getExecutedSurplusFee(orders).toString();	×
127
128	const [sellToken, buyToken] = await Promise.all([	×
129	this.swapOrderHelper.getToken({
130	chainId,
131	address: twapStruct.sellToken,
132	}),
133	this.swapOrderHelper.getToken({
134	chainId,
135	address: twapStruct.buyToken,
136	}),
137	]);
138
139	return new TwapOrderTransactionInfo({	×
140	status: this.getOrderStatus(orders),
141	kind: twapOrderData.kind,
142	class: twapOrderData.class,
143	validUntil: Math.max(...twapParts.map((order) => order.validTo)),	×
144	sellAmount: twapOrderData.sellAmount,
145	buyAmount: twapOrderData.buyAmount,
146	executedSellAmount,
147	executedBuyAmount,
148	executedSurplusFee,
149	sellToken: new TokenInfo({
150	address: sellToken.address,
151	decimals: sellToken.decimals,
152	logoUri: sellToken.logoUri,
153	name: sellToken.name,
154	symbol: sellToken.symbol,
155	trusted: sellToken.trusted,
156	}),
157	buyToken: new TokenInfo({
158	address: buyToken.address,
159	decimals: buyToken.decimals,
160	logoUri: buyToken.logoUri,
161	name: buyToken.name,
162	symbol: buyToken.symbol,
163	trusted: buyToken.trusted,
164	}),
165	receiver: twapStruct.receiver,
166	owner: safeAddress,
167	fullAppData: fullAppData.fullAppData,
168	numberOfParts: twapOrderData.numberOfParts,
169	partSellAmount: twapStruct.partSellAmount.toString(),
170	minPartLimit: twapStruct.minPartLimit.toString(),
171	timeBetweenParts: twapOrderData.timeBetweenParts,
172	durationOfPart: twapOrderData.durationOfPart,
173	startTime: twapOrderData.startTime,
174	});
175	}
176
177	private getOrderStatus(
178	orders: Array<Awaited<ReturnType<typeof this.swapOrderHelper.getOrder>>>,
179	): OrderStatus {
180	if (orders.length === 0) {	×
181	return OrderStatus.PreSignaturePending;	×
182	}
183
184	// If an order is fulfilled, cancelled or expired, the part is "complete"
185	const completeStatuses = [	×
186	OrderStatus.Fulfilled,
187	OrderStatus.Cancelled,
188	OrderStatus.Expired,
189	];
190
191	for (let i = 0; i < orders.length; i++) {	×
192	const order = orders[i];	×
193
194	// Return the status of the last part
195	if (i === orders.length - 1) {	×
196	return order.status;	×
197	}
198
199	// If the part is complete, continue to the next part
200	if (completeStatuses.includes(order.status)) {	×
201	continue;	×
202	}
203
204	return order.status;	×
205	}
206
207	return OrderStatus.Unknown;	×
208	}
209
210	private getExecutedSellAmount(orders: Array<KnownOrder>): bigint {
211	return orders.reduce((acc, order) => {	×
212	return acc + BigInt(order.executedSellAmount);	×
213	}, BigInt(0));
214	}
215
216	private getExecutedBuyAmount(orders: Array<KnownOrder>): bigint {
217	return orders.reduce((acc, order) => {	×
218	return acc + BigInt(order.executedBuyAmount);	×
219	}, BigInt(0));
220	}
221
222	private getExecutedSurplusFee(orders: Array<KnownOrder>): bigint {
223	return orders.reduce((acc, order) => {	×
224	return acc + BigInt(order.executedSurplusFee ?? BigInt(0));	×
225	}, BigInt(0));
226	}
227	}
228
229	@Module({
230	imports: [
231	SwapOrderHelperModule,
232	SwapsRepositoryModule,
233	SwapOrderMapperModule,
234	TwapOrderHelperModule,
235	],
236	providers: [ComposableCowDecoder, GPv2OrderHelper, TwapOrderMapper],
237	exports: [TwapOrderMapper],
238	})
239	export class TwapOrderMapperModule {}	16✔

safe-global / safe-client-gateway / 9784936466

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