9581748889

Committed 19 Jun 2024 12:11PM UTC coverage: 49.275% (+0.001%) from 49.274%

Build # 9581748889

Build Type

Pull #1670

github

Committed by

iamacook

Commit Message

Merge branch 'main' into limit-twap-parts

Pull Request Pull Request #1670: Limit maximum amount of TWAP parts

Run Details

415 of 2443 branches covered (16.99%)

Branch coverage included in aggregate %.

5 of 11 new or added lines in 2 files covered. (45.45%)

1 existing line in 1 file now uncovered.

4073 of 6665 relevant lines covered (61.11%)

12.81 hits per line

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

28.77

/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 {
  DurationType,
  StartTimeValue,
  TwapOrderInfo,
  TwapOrderTransactionInfo,
} from '@/routes/transactions/entities/swaps/twap-order-info.entity';
import {
  TwapOrderHelper,
  TwapOrderHelperModule,
} from '@/routes/transactions/helpers/twap-order.helper';
import {
  OrderClass,
  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';

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

  constructor(
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    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 },
  ): Promise<TwapOrderTransactionInfo> {
    // Decode `staticInput` of `createWithContextCall`
    const twapStruct = this.composableCowDecoder.decodeTwapStruct(
      transaction.data,
    );

    // Generate parts of the TWAP order
    const twapParts = this.twapOrderHelper.generateTwapOrderParts({
      twapStruct,
      executionDate: transaction.executionDate,
      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;

    const partsToFetch = 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 }, ...orders] = await Promise.all([
      // Decode hash of `appData`
      this.swapsRepository.getFullAppData(chainId, twapStruct.appData),
      // Fetch all order parts
      ...partsToFetch.map((order) => {
        const orderUid = this.gpv2OrderHelper.computeOrderUid({
          chainId,
          owner: safeAddress,
          order,
        });
        return this.swapOrderHelper.getOrder({ chainId, orderUid });
      }),
    ]);

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

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

    // All orders have the same sellToken and buyToken
    const { sellToken, buyToken } = orders[0];

    const { n: numberOfParts, partSellAmount, minPartLimit } = twapStruct;
    const span = Number(twapStruct.span);
    const sellAmount = partSellAmount * numberOfParts;
    const buyAmount = minPartLimit * numberOfParts;

    return new TwapOrderTransactionInfo({
      orderStatus: this.getOrderStatus(orders),
      kind: OrderKind.Sell,
      class: OrderClass.Limit,
      validUntil: Math.max(...partsToFetch.map((order) => order.validTo)),
      sellAmount: sellAmount.toString(),
      buyAmount: buyAmount.toString(),
      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: Number(numberOfParts),
      partSellAmount: partSellAmount.toString(),
      minPartLimit: minPartLimit.toString(),
      timeBetweenParts: twapStruct.t.toString(),
      durationOfPart: this.getDurationOfPart(span),
      startTime: this.getStartTime({ span, startEpoch: Number(twapStruct.t0) }),
    });
  }

  private getOrderStatus(
    orders: Array<Awaited<ReturnType<typeof this.swapOrderHelper.getOrder>>>,
  ): OrderStatus {
    // 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<Awaited<ReturnType<typeof this.swapOrderHelper.getOrder>>>,
  ): number {
    return orders.reduce((acc, { order }) => {
      return acc + Number(order.executedSellAmount);
    }, 0);
  }

  private getExecutedBuyAmount(
    orders: Array<Awaited<ReturnType<typeof this.swapOrderHelper.getOrder>>>,
  ): number {
    return orders.reduce((acc, { order }) => {
      return acc + Number(order.executedBuyAmount);
    }, 0);
  }

  private getDurationOfPart(span: number): TwapOrderInfo['durationOfPart'] {
    if (span === 0) {
      return { durationType: DurationType.Auto };
    }
    return { durationType: DurationType.LimitDuration, duration: span };
  }

  private getStartTime(args: {
    span: number;
    startEpoch: number;
  }): TwapOrderInfo['startTime'] {
    if (args.span === 0) {
      return { startType: StartTimeValue.AtMiningTime };
    }
    return { startType: StartTimeValue.AtEpoch, epoch: args.startEpoch };
  }
}

@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	DurationType,
10	StartTimeValue,
11	TwapOrderInfo,
12	TwapOrderTransactionInfo,
13	} from '@/routes/transactions/entities/swaps/twap-order-info.entity';
14	import {	16✔
15	TwapOrderHelper,
16	TwapOrderHelperModule,
17	} from '@/routes/transactions/helpers/twap-order.helper';
18	import {	16✔
19	OrderClass,
20	OrderKind,
21	OrderStatus,
22	} from '@/domain/swaps/entities/order.entity';
23	import { ISwapsRepository } from '@/domain/swaps/swaps.repository';	16✔
24	import { SwapsRepositoryModule } from '@/domain/swaps/swaps-repository.module';	16✔
25	import { SwapOrderMapperModule } from '@/routes/transactions/mappers/common/swap-order.mapper';	16✔
26	import { GPv2OrderHelper } from '@/routes/transactions/helpers/gp-v2-order.helper';	16✔
27	import { IConfigurationService } from '@/config/configuration.service.interface';	16✔
28
29	@Injectable()
30	export class TwapOrderMapper {	16✔
31	private maxNumberOfParts: number;
32
33	constructor(
34	@Inject(IConfigurationService)
35	private readonly configurationService: IConfigurationService,	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 },
60	): Promise<TwapOrderTransactionInfo> {
61	// Decode `staticInput` of `createWithContextCall`
62	const twapStruct = this.composableCowDecoder.decodeTwapStruct(	×
63	transaction.data,
64	);
65
66	// Generate parts of the TWAP order
NEW 67	const twapParts = this.twapOrderHelper.generateTwapOrderParts({	×
68	twapStruct,
69	executionDate: transaction.executionDate,
70	chainId,
71	});
72
73	// There can be up to uint256 parts in a TWAP order so we limit this
74	// to avoid requesting too many orders
NEW 75	const hasAbundantParts = twapParts.length > this.maxNumberOfParts;	×
76
NEW 77	const partsToFetch = hasAbundantParts	×
78	? // We use the last part (and only one) to get the status of the entire
79	// order and we only need one to get the token info
80	twapParts.slice(-1)
81	: twapParts;
82
UNCOV 83	const [{ fullAppData }, ...orders] = await Promise.all([	×
84	// Decode hash of `appData`
85	this.swapsRepository.getFullAppData(chainId, twapStruct.appData),
86	// Fetch all order parts
87	...partsToFetch.map((order) => {
88	const orderUid = this.gpv2OrderHelper.computeOrderUid({	×
89	chainId,
90	owner: safeAddress,
91	order,
92	});
93	return this.swapOrderHelper.getOrder({ chainId, orderUid });	×
94	}),
95	]);
96
97	const executedSellAmount: TwapOrderInfo['executedSellAmount'] =
NEW 98	hasAbundantParts ? null : this.getExecutedSellAmount(orders).toString();	×
99
100	const executedBuyAmount: TwapOrderInfo['executedBuyAmount'] =
NEW 101	hasAbundantParts ? null : this.getExecutedBuyAmount(orders).toString();	×
102
103	// All orders have the same sellToken and buyToken
104	const { sellToken, buyToken } = orders[0];	×
105
106	const { n: numberOfParts, partSellAmount, minPartLimit } = twapStruct;	×
107	const span = Number(twapStruct.span);	×
108	const sellAmount = partSellAmount * numberOfParts;	×
109	const buyAmount = minPartLimit * numberOfParts;	×
110
111	return new TwapOrderTransactionInfo({	×
112	orderStatus: this.getOrderStatus(orders),
113	kind: OrderKind.Sell,
114	class: OrderClass.Limit,
NEW 115	validUntil: Math.max(...partsToFetch.map((order) => order.validTo)),	×
116	sellAmount: sellAmount.toString(),
117	buyAmount: buyAmount.toString(),
118	executedSellAmount,
119	executedBuyAmount,
120	sellToken: new TokenInfo({
121	address: sellToken.address,
122	decimals: sellToken.decimals,
123	logoUri: sellToken.logoUri,
124	name: sellToken.name,
125	symbol: sellToken.symbol,
126	trusted: sellToken.trusted,
127	}),
128	buyToken: new TokenInfo({
129	address: buyToken.address,
130	decimals: buyToken.decimals,
131	logoUri: buyToken.logoUri,
132	name: buyToken.name,
133	symbol: buyToken.symbol,
134	trusted: buyToken.trusted,
135	}),
136	receiver: twapStruct.receiver,
137	owner: safeAddress,
138	fullAppData,
139	numberOfParts: Number(numberOfParts),
140	partSellAmount: partSellAmount.toString(),
141	minPartLimit: minPartLimit.toString(),
142	timeBetweenParts: twapStruct.t.toString(),
143	durationOfPart: this.getDurationOfPart(span),
144	startTime: this.getStartTime({ span, startEpoch: Number(twapStruct.t0) }),
145	});
146	}
147
148	private getOrderStatus(
149	orders: Array<Awaited<ReturnType<typeof this.swapOrderHelper.getOrder>>>,
150	): OrderStatus {
151	// If an order is fulfilled, cancelled or expired, the part is "complete"
152	const completeStatuses = [	×
153	OrderStatus.Fulfilled,
154	OrderStatus.Cancelled,
155	OrderStatus.Expired,
156	];
157
158	for (let i = 0; i < orders.length; i++) {	×
159	const { order } = orders[i];	×
160
161	// Return the status of the last part
162	if (i === orders.length - 1) {	×
163	return order.status;	×
164	}
165
166	// If the part is complete, continue to the next part
167	if (completeStatuses.includes(order.status)) {	×
168	continue;	×
169	}
170
171	return order.status;	×
172	}
173
174	return OrderStatus.Unknown;	×
175	}
176
177	private getExecutedSellAmount(
178	orders: Array<Awaited<ReturnType<typeof this.swapOrderHelper.getOrder>>>,
179	): number {
180	return orders.reduce((acc, { order }) => {	×
181	return acc + Number(order.executedSellAmount);	×
182	}, 0);
183	}
184
185	private getExecutedBuyAmount(
186	orders: Array<Awaited<ReturnType<typeof this.swapOrderHelper.getOrder>>>,
187	): number {
188	return orders.reduce((acc, { order }) => {	×
189	return acc + Number(order.executedBuyAmount);	×
190	}, 0);
191	}
192
193	private getDurationOfPart(span: number): TwapOrderInfo['durationOfPart'] {
194	if (span === 0) {	×
195	return { durationType: DurationType.Auto };	×
196	}
197	return { durationType: DurationType.LimitDuration, duration: span };	×
198	}
199
200	private getStartTime(args: {
201	span: number;
202	startEpoch: number;
203	}): TwapOrderInfo['startTime'] {
204	if (args.span === 0) {	×
205	return { startType: StartTimeValue.AtMiningTime };	×
206	}
207	return { startType: StartTimeValue.AtEpoch, epoch: args.startEpoch };	×
208	}
209	}
210
211	@Module({
212	imports: [
213	SwapOrderHelperModule,
214	SwapsRepositoryModule,
215	SwapOrderMapperModule,
216	TwapOrderHelperModule,
217	],
218	providers: [ComposableCowDecoder, GPv2OrderHelper, TwapOrderMapper],
219	exports: [TwapOrderMapper],
220	})
221	export class TwapOrderMapperModule {}	16✔

safe-global / safe-client-gateway / 9581748889

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