10079110198

Committed 24 Jul 2024 03:01PM UTC coverage: 48.395% (-0.06%) from 48.454%

Build # 10079110198

Build Type

Pull #1785

github

Committed by

web-flow

Commit Message

Merge 88c9d4e6c into b4f144746

Pull Request Pull Request #1785: Mark TWAP orders as `unknown` if getting part orders fails

Run Details

437 of 2642 branches covered (16.54%)

Branch coverage included in aggregate %.

0 of 19 new or added lines in 1 file covered. (0.0%)

25 existing lines in 3 files now uncovered.

4326 of 7200 relevant lines covered (60.08%)

13.02 hits per line

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

18.66

/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';
import {
  SwapAppsHelper,
  SwapAppsHelperModule,
} from '@/routes/transactions/helpers/swap-apps.helper';
import { GPv2OrderParameters } from '@/domain/swaps/contracts/decoders/gp-v2-decoder.helper';

@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,
    private readonly swapAppsHelper: SwapAppsHelper,
  ) {
    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,
    });

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

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

    // 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 orders = await this.getOrdersForParts({
      partsToFetch,
      chainId,
      safeAddress,
    });

    const status = !orders ? OrderStatus.Unknown : this.getOrderStatus(orders);

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

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

    const executedSurplusFee: TwapOrderInfo['executedSurplusFee'] =
      hasAbundantParts || !orders
        ? 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,
      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 async getOrdersForParts(args: {
    partsToFetch: Array<GPv2OrderParameters>;
    chainId: string;
    safeAddress: `0x${string}`;
  }): Promise<Array<KnownOrder> | null> {
    const orders: Array<KnownOrder> = [];

    for (const part of args.partsToFetch) {
      const partFullAppData = await this.swapsRepository.getFullAppData(
        args.chainId,
        part.appData,
      );

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

      const orderUid = this.gpv2OrderHelper.computeOrderUid({
        chainId: args.chainId,
        owner: args.safeAddress,
        order: part,
      });
      const order = await this.swapsRepository
        .getOrder(args.chainId, orderUid)
        .catch(() => {
          this.loggingService.warn(
            `Error getting orderUid ${orderUid} from SwapsRepository`,
          );
        });

      if (!order || order.kind == OrderKind.Unknown) {
        // Without every order it's not possible to determine status or executed amounts/fees
        return null;
      }

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

      orders.push(order as KnownOrder);
    }

    return orders;
  }

  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,
    SwapAppsHelperModule,
  ],
  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	import {	16✔
28	SwapAppsHelper,
29	SwapAppsHelperModule,
30	} from '@/routes/transactions/helpers/swap-apps.helper';
31	import { GPv2OrderParameters } from '@/domain/swaps/contracts/decoders/gp-v2-decoder.helper';
32
33	@Injectable()
34	export class TwapOrderMapper {	16✔
35	private maxNumberOfParts: number;
36
37	constructor(
38	@Inject(IConfigurationService)
39	private readonly configurationService: IConfigurationService,	16✔
40	@Inject(LoggingService) private readonly loggingService: ILoggingService,	16✔
41	private readonly swapOrderHelper: SwapOrderHelper,	16✔
42	@Inject(ISwapsRepository)
43	private readonly swapsRepository: ISwapsRepository,	16✔
44	private readonly composableCowDecoder: ComposableCowDecoder,	16✔
45	private readonly gpv2OrderHelper: GPv2OrderHelper,	16✔
46	private readonly twapOrderHelper: TwapOrderHelper,	16✔
47	private readonly swapAppsHelper: SwapAppsHelper,	16✔
48	) {
49	this.maxNumberOfParts = this.configurationService.getOrThrow(	16✔
50	'swaps.maxNumberOfParts',
51	);
52	}
53
54	/**
55	* Maps a TWAP order from a given transaction
56	*
57	* @param chainId - chain the order is on
58	* @param safeAddress - "owner" of the order
59	* @param transaction - transaction data and execution date
60	* @returns mapped {@link TwapOrderTransactionInfo}
61	*/
62	async mapTwapOrder(
63	chainId: string,
64	safeAddress: `0x${string}`,
65	transaction: { data: `0x${string}`; executionDate: Date \| null },
66	): Promise<TwapOrderTransactionInfo> {
67	// Decode `staticInput` of `createWithContextCall`
68	const twapStruct = this.composableCowDecoder.decodeTwapStruct(	×
69	transaction.data,
70	);
71	const twapOrderData =
72	this.twapOrderHelper.twapStructToPartialOrderInfo(twapStruct);	×
73
74	// Generate parts of the TWAP order
75	const twapParts = this.twapOrderHelper.generateTwapOrderParts({	×
76	twapStruct,
77	executionDate: transaction.executionDate ?? new Date(),	×
78	chainId,
79	});
80
81	const fullAppData = await this.swapsRepository.getFullAppData(	×
82	chainId,
83	twapStruct.appData,
84	);
85
86	if (!this.swapAppsHelper.isAppAllowed(fullAppData)) {	×
87	throw new Error(`Unsupported App: ${fullAppData.fullAppData?.appCode}`);	×
88	}
89
90	// There can be up to uint256 parts in a TWAP order so we limit this
91	// to avoid requesting too many orders
92	const hasAbundantParts = twapParts.length > this.maxNumberOfParts;	×
93
94	// Fetch all order parts if the transaction has been executed, otherwise none
95	const partsToFetch = transaction.executionDate	×
96	? hasAbundantParts	×
97	? // We use the last part (and only one) to get the status of the entire
98	// order and we only need one to get the token info
99	twapParts.slice(-1)
100	: twapParts
101	: [];
102
NEW 103	const orders = await this.getOrdersForParts({	×
104	partsToFetch,
105	chainId,
106	safeAddress,
107	});
108
NEW 109	const status = !orders ? OrderStatus.Unknown : this.getOrderStatus(orders);	×
110
111	const executedSellAmount: TwapOrderInfo['executedSellAmount'] =
NEW 112	hasAbundantParts \|\| !orders	×
113	? null
114	: this.getExecutedSellAmount(orders).toString();
115
116	const executedBuyAmount: TwapOrderInfo['executedBuyAmount'] =
NEW 117	hasAbundantParts \|\| !orders	×
118	? null
119	: this.getExecutedBuyAmount(orders).toString();
120
121	const executedSurplusFee: TwapOrderInfo['executedSurplusFee'] =
NEW 122	hasAbundantParts \|\| !orders	×
123	? null
124	: this.getExecutedSurplusFee(orders).toString();
125
126	const [sellToken, buyToken] = await Promise.all([	×
127	this.swapOrderHelper.getToken({
128	chainId,
129	address: twapStruct.sellToken,
130	}),
131	this.swapOrderHelper.getToken({
132	chainId,
133	address: twapStruct.buyToken,
134	}),
135	]);
136
137	return new TwapOrderTransactionInfo({	×
138	status,
139	kind: twapOrderData.kind,
140	class: twapOrderData.class,
UNCOV 141	validUntil: Math.max(...twapParts.map((order) => order.validTo)),	×
142	sellAmount: twapOrderData.sellAmount,
143	buyAmount: twapOrderData.buyAmount,
144	executedSellAmount,
145	executedBuyAmount,
146	executedSurplusFee,
147	sellToken: new TokenInfo({
148	address: sellToken.address,
149	decimals: sellToken.decimals,
150	logoUri: sellToken.logoUri,
151	name: sellToken.name,
152	symbol: sellToken.symbol,
153	trusted: sellToken.trusted,
154	}),
155	buyToken: new TokenInfo({
156	address: buyToken.address,
157	decimals: buyToken.decimals,
158	logoUri: buyToken.logoUri,
159	name: buyToken.name,
160	symbol: buyToken.symbol,
161	trusted: buyToken.trusted,
162	}),
163	receiver: twapStruct.receiver,
164	owner: safeAddress,
165	fullAppData: fullAppData.fullAppData,
166	numberOfParts: twapOrderData.numberOfParts,
167	partSellAmount: twapStruct.partSellAmount.toString(),
168	minPartLimit: twapStruct.minPartLimit.toString(),
169	timeBetweenParts: twapOrderData.timeBetweenParts,
170	durationOfPart: twapOrderData.durationOfPart,
171	startTime: twapOrderData.startTime,
172	});
173	}
174
175	private async getOrdersForParts(args: {
176	partsToFetch: Array<GPv2OrderParameters>;
177	chainId: string;
178	safeAddress: `0x${string}`;
179	}): Promise<Array<KnownOrder> \| null> {
NEW UNCOV 180	const orders: Array<KnownOrder> = [];	×
181
NEW UNCOV 182	for (const part of args.partsToFetch) {	×
NEW UNCOV 183	const partFullAppData = await this.swapsRepository.getFullAppData(	×
184	args.chainId,
185	part.appData,
186	);
187
NEW UNCOV 188	if (!this.swapAppsHelper.isAppAllowed(partFullAppData)) {	×
NEW UNCOV 189	throw new Error(	×
190	`Unsupported App: ${partFullAppData.fullAppData?.appCode}`,	×
191	);
192	}
193
NEW UNCOV 194	const orderUid = this.gpv2OrderHelper.computeOrderUid({	×
195	chainId: args.chainId,
196	owner: args.safeAddress,
197	order: part,
198	});
NEW 199	const order = await this.swapsRepository	×
200	.getOrder(args.chainId, orderUid)
201	.catch(() => {
NEW UNCOV 202	this.loggingService.warn(	×
203	`Error getting orderUid ${orderUid} from SwapsRepository`,
204	);
205	});
206
NEW 207	if (!order \|\| order.kind == OrderKind.Unknown) {	×
208	// Without every order it's not possible to determine status or executed amounts/fees
NEW 209	return null;	×
210	}
211
NEW 212	if (!this.swapAppsHelper.isAppAllowed(order)) {	×
NEW 213	throw new Error(`Unsupported App: ${order.fullAppData?.appCode}`);	×
214	}
215
NEW 216	orders.push(order as KnownOrder);	×
217	}
218
NEW 219	return orders;	×
220	}
221
222	private getOrderStatus(
223	orders: Array<Awaited<ReturnType<typeof this.swapOrderHelper.getOrder>>>,
224	): OrderStatus {
225	if (orders.length === 0) {	×
226	return OrderStatus.PreSignaturePending;	×
227	}
228
229	// If an order is fulfilled, cancelled or expired, the part is "complete"
UNCOV 230	const completeStatuses = [	×
231	OrderStatus.Fulfilled,
232	OrderStatus.Cancelled,
233	OrderStatus.Expired,
234	];
235
236	for (let i = 0; i < orders.length; i++) {	×
237	const order = orders[i];	×
238
239	// Return the status of the last part
240	if (i === orders.length - 1) {	×
241	return order.status;	×
242	}
243
244	// If the part is complete, continue to the next part
245	if (completeStatuses.includes(order.status)) {	×
246	continue;	×
247	}
248
249	return order.status;	×
250	}
251
252	return OrderStatus.Unknown;	×
253	}
254
255	private getExecutedSellAmount(orders: Array<KnownOrder>): bigint {
256	return orders.reduce((acc, order) => {	×
257	return acc + BigInt(order.executedSellAmount);	×
258	}, BigInt(0));
259	}
260
261	private getExecutedBuyAmount(orders: Array<KnownOrder>): bigint {
262	return orders.reduce((acc, order) => {	×
263	return acc + BigInt(order.executedBuyAmount);	×
264	}, BigInt(0));
265	}
266
267	private getExecutedSurplusFee(orders: Array<KnownOrder>): bigint {
268	return orders.reduce((acc, order) => {	×
UNCOV 269	return acc + BigInt(order.executedSurplusFee ?? BigInt(0));	×
270	}, BigInt(0));
271	}
272	}
273
274	@Module({
275	imports: [
276	SwapOrderHelperModule,
277	SwapsRepositoryModule,
278	SwapOrderMapperModule,
279	TwapOrderHelperModule,
280	SwapAppsHelperModule,
281	],
282	providers: [ComposableCowDecoder, GPv2OrderHelper, TwapOrderMapper],
283	exports: [TwapOrderMapper],
284	})
285	export class TwapOrderMapperModule {}	16✔

safe-global / safe-client-gateway / 10079110198

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