9713769769

Committed 27 Jun 2024 09:20PM UTC coverage: 48.767% (-0.04%) from 48.808%

Build # 9713769769

Build Type

push

github

Committed by

web-flow

Commit Message

Catch swapOrderHelper.getOrder errors (#1699)

Catch swapOrderHelper.getOrder errors

Run Details

412 of 2510 branches covered (16.41%)

Branch coverage included in aggregate %.

3 of 12 new or added lines in 1 file covered. (25.0%)

2 existing lines in 1 file now uncovered.

4195 of 6937 relevant lines covered (60.47%)

13.17 hits per line

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

28.05

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

    // TODO: Handling of restricted Apps, 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 [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,
      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,
      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>): number {
    return orders.reduce((acc, order) => {
      return acc + Number(order.executedSellAmount);
    }, 0);
  }

  private getExecutedBuyAmount(orders: Array<KnownOrder>): number {
    return orders.reduce((acc, order) => {
      return acc + Number(order.executedBuyAmount);
    }, 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
NEW 93	const orders: Array<KnownOrder> = [];	×
94
NEW 95	for (const part of partsToFetch) {	×
NEW 96	const orderUid = this.gpv2OrderHelper.computeOrderUid({	×
97	chainId,
98	owner: safeAddress,
99	order: part,
100	});
101
NEW 102	try {	×
NEW 103	const order = await this.swapsRepository.getOrder(chainId, orderUid);	×
NEW 104	if (order.kind === OrderKind.Buy \|\| order.kind === OrderKind.Sell) {	×
NEW 105	orders.push(order as KnownOrder);	×
106	}
107	} catch (err) {
NEW 108	this.loggingService.warn(	×
109	`Error getting orderUid ${orderUid} from SwapsRepository`,
110	);
111	}
112	}
113
114	// TODO: Handling of restricted Apps, calling `getToken` directly instead of multiple times in `getOrder` for sellToken and buyToken
115
116	const executedSellAmount: TwapOrderInfo['executedSellAmount'] =
117	hasAbundantParts ? null : this.getExecutedSellAmount(orders).toString();	×
118
119	const executedBuyAmount: TwapOrderInfo['executedBuyAmount'] =
120	hasAbundantParts ? null : this.getExecutedBuyAmount(orders).toString();	×
121
122	const [sellToken, buyToken] = await Promise.all([	×
123	this.swapOrderHelper.getToken({
124	chainId,
125	address: twapStruct.sellToken,
126	}),
127	this.swapOrderHelper.getToken({
128	chainId,
129	address: twapStruct.buyToken,
130	}),
131	]);
132
133	return new TwapOrderTransactionInfo({	×
134	status: this.getOrderStatus(orders),
135	kind: twapOrderData.kind,
136	class: twapOrderData.class,
137	validUntil: Math.max(...twapParts.map((order) => order.validTo)),	×
138	sellAmount: twapOrderData.sellAmount,
139	buyAmount: twapOrderData.buyAmount,
140	executedSellAmount,
141	executedBuyAmount,
142	sellToken: new TokenInfo({
143	address: sellToken.address,
144	decimals: sellToken.decimals,
145	logoUri: sellToken.logoUri,
146	name: sellToken.name,
147	symbol: sellToken.symbol,
148	trusted: sellToken.trusted,
149	}),
150	buyToken: new TokenInfo({
151	address: buyToken.address,
152	decimals: buyToken.decimals,
153	logoUri: buyToken.logoUri,
154	name: buyToken.name,
155	symbol: buyToken.symbol,
156	trusted: buyToken.trusted,
157	}),
158	receiver: twapStruct.receiver,
159	owner: safeAddress,
160	fullAppData,
161	numberOfParts: twapOrderData.numberOfParts,
162	partSellAmount: twapStruct.partSellAmount.toString(),
163	minPartLimit: twapStruct.minPartLimit.toString(),
164	timeBetweenParts: twapOrderData.timeBetweenParts,
165	durationOfPart: twapOrderData.durationOfPart,
166	startTime: twapOrderData.startTime,
167	});
168	}
169
170	private getOrderStatus(
171	orders: Array<Awaited<ReturnType<typeof this.swapOrderHelper.getOrder>>>,
172	): OrderStatus {
173	if (orders.length === 0) {	×
174	return OrderStatus.PreSignaturePending;	×
175	}
176
177	// If an order is fulfilled, cancelled or expired, the part is "complete"
178	const completeStatuses = [	×
179	OrderStatus.Fulfilled,
180	OrderStatus.Cancelled,
181	OrderStatus.Expired,
182	];
183
184	for (let i = 0; i < orders.length; i++) {	×
185	const order = orders[i];	×
186
187	// Return the status of the last part
188	if (i === orders.length - 1) {	×
189	return order.status;	×
190	}
191
192	// If the part is complete, continue to the next part
193	if (completeStatuses.includes(order.status)) {	×
194	continue;	×
195	}
196
197	return order.status;	×
198	}
199
200	return OrderStatus.Unknown;	×
201	}
202
203	private getExecutedSellAmount(orders: Array<KnownOrder>): number {
UNCOV 204	return orders.reduce((acc, order) => {	×
205	return acc + Number(order.executedSellAmount);	×
206	}, 0);
207	}
208
209	private getExecutedBuyAmount(orders: Array<KnownOrder>): number {
UNCOV 210	return orders.reduce((acc, order) => {	×
211	return acc + Number(order.executedBuyAmount);	×
212	}, 0);
213	}
214	}
215
216	@Module({
217	imports: [
218	SwapOrderHelperModule,
219	SwapsRepositoryModule,
220	SwapOrderMapperModule,
221	TwapOrderHelperModule,
222	],
223	providers: [ComposableCowDecoder, GPv2OrderHelper, TwapOrderMapper],
224	exports: [TwapOrderMapper],
225	})
226	export class TwapOrderMapperModule {}	16✔

safe-global / safe-client-gateway / 9713769769

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