10091014593

Committed 25 Jul 2024 08:45AM UTC coverage: 48.273% (+0.005%) from 48.268%

Build # 10091014593

Build Type

push

github

Committed by

iamacook

Commit Message

Adjust status calculation logic

Run Details

437 of 2660 branches covered (16.43%)

Branch coverage included in aggregate %.

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

2 existing lines in 1 file now uncovered.

4328 of 7211 relevant lines covered (60.02%)

13.01 hits per line

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

15.72

/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,
  Order,
  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 amounts/fees of the entire
          // order and we only need one to get the token info
          twapParts.slice(-1)
        : twapParts
      : [];

    const activePart = this.getActivePart({
      twapParts,
      executionDate: transaction.executionDate,
    });

    const activeOrderUid = activePart
      ? this.gpv2OrderHelper.computeOrderUid({
          chainId: chainId,
          owner: safeAddress,
          order: activePart,
        })
      : null;

    const partOrders = await this.getPartOrders({
      partsToFetch,
      chainId,
      safeAddress,
    });

    const status = await this.getOrderStatus({
      chainId,
      safeAddress,
      twapParts,
      partOrders,
      activeOrderUid,
      executionDate: transaction.executionDate,
    });

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

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

    const executedSurplusFee: TwapOrderInfo['executedSurplusFee'] =
      hasAbundantParts || !partOrders
        ? null
        : this.getExecutedSurplusFee(partOrders).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,
      activeOrderUid,
      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 getActivePart(args: {
    twapParts: Array<GPv2OrderParameters>;
    executionDate: Date | null;
  }): GPv2OrderParameters | null {
    if (!args.executionDate) {
      return null;
    }

    const now = new Date();
    const activePart = args.twapParts.find((part) => {
      return part.validTo > Math.floor(now.getTime() / 1_000);
    });

    return activePart ?? null;
  }

  private async getPartOrders(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 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 async getOrderStatus(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    twapParts: Array<GPv2OrderParameters>;
    partOrders: Array<KnownOrder> | null;
    activeOrderUid: `0x${string}` | null;
    executionDate: Date | null;
  }): Promise<OrderStatus> {
    if (!args.executionDate) {
      return OrderStatus.PreSignaturePending;
    }

    // Note: TWAPs can never "expire" in their entirety, only parts can but
    // this does not affect TWAP status

    // Check active or final order part depending on whether the TWAP is active
    const orderUidToCheck =
      args.activeOrderUid ??
      this.gpv2OrderHelper.computeOrderUid({
        chainId: args.chainId,
        owner: args.safeAddress,
        order: args.twapParts.slice(-1)[0], // Last part's order
      });

    try {
      // If we already fetched the order, we don't need to do it again
      const orderAlreadyFetched = !!args.partOrders?.some(
        (order) => order.uid === orderUidToCheck,
      );
      if (!orderAlreadyFetched) {
        await this.swapsRepository.getOrder(args.chainId, orderUidToCheck);
      }

      // If the order was created, the TWAP is either open or fulfilled depending
      // on whether the order part is active
      return args.activeOrderUid ? OrderStatus.Open : OrderStatus.Fulfilled;
    } catch {
      // If the order doesn't exist, it means the TWAP was cancelled
      return OrderStatus.Cancelled;
    }
  }

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

safe-global / safe-client-gateway / 10091014593

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