9796547219

Committed 04 Jul 2024 03:03PM UTC coverage: 48.394% (-0.1%) from 48.501%

Build # 9796547219

Build Type

Pull #1698

github

Committed by

web-flow

Commit Message

Merge 361ec719f into 2cb5415c4

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

Run Details

416 of 2577 branches covered (16.14%)

Branch coverage included in aggregate %.

7 of 20 new or added lines in 3 files covered. (35.0%)

59 existing lines in 7 files now uncovered.

4225 of 7013 relevant lines covered (60.25%)

13.16 hits per line

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

26.98

/src/routes/transactions/helpers/twap-order.helper.ts

import { MultiSendDecoder } from '@/domain/contracts/decoders/multi-send-decoder.helper';
import {
  ComposableCowDecoder,
  TwapStruct,
} from '@/domain/swaps/contracts/decoders/composable-cow-decoder.helper';
import {
  BuyTokenBalance,
  OrderClass,
  OrderKind,
  SellTokenBalance,
} from '@/domain/swaps/entities/order.entity';
import {
  DurationType,
  StartTimeValue,
  DurationOfPart,
  StartTime,
  TwapOrderInfo,
} from '@/routes/transactions/entities/swaps/twap-order-info.entity';
import { GPv2OrderParameters } from '@/domain/swaps/contracts/decoders/gp-v2-decoder.helper';
import { Inject, Injectable, Module } from '@nestjs/common';
import { isAddressEqual } from 'viem';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { FullAppData } from '@/domain/swaps/entities/full-app-data.entity';

/**
 *
 * @see https://github.com/cowprotocol/contracts/blob/1465e69f6935b3ef9ce45d4878e44f0335ef8531/src/ts/order.ts
 */
@Injectable()
export class TwapOrderHelper {
  private static readonly ComposableCowAddress =
    '0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74' as const;

  private readonly restrictApps: boolean;

  constructor(
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    private readonly multiSendDecoder: MultiSendDecoder,
    private readonly composableCowDecoder: ComposableCowDecoder,
    @Inject('SWAP_ALLOWED_APPS') private readonly allowedApps: Set<string>,
  ) {
    this.restrictApps =
      this.configurationService.getOrThrow<boolean>('swaps.restrictApps');
  }

  // TODO: Refactor findSwapOrder, findSwapTransfer and findTwapOrder to avoid code duplication

  /**
   * Finds a TWAP order in a given transaction, either directly called or in a MultiSend
   *
   * @param args.to - recipient of the transaction
   * @param args.data - data of the transaction
   * @returns TWAP order data if found, otherwise null
   */
  public findTwapOrder(args: {
    to: `0x${string}`;
    data: `0x${string}`;
  }): `0x${string}` | null {
    if (this.isTwapOrder(args)) {
      return args.data;
    }

    if (this.multiSendDecoder.helpers.isMultiSend(args.data)) {
      const transactions = this.multiSendDecoder.mapMultiSendTransactions(
        args.data,
      );

      for (const transaction of transactions) {
        if (this.isTwapOrder(transaction)) {
          return transaction.data;
        }
      }
    }

    return null;
  }

  private isTwapOrder(args: {
    to: `0x${string}`;
    data: `0x${string}`;
  }): boolean {
    return (
      isAddressEqual(args.to, TwapOrderHelper.ComposableCowAddress) &&
      this.composableCowDecoder.helpers.isCreateWithContext(args.data)
    );
  }

  /**
   * Maps values of {@link TwapStruct} to partial {@link TwapOrderInfo}
   *
   * @param struct - {@link TwapStruct} to map
   * @returns partial mapping of {@link TwapOrderInfo}
   */
  public twapStructToPartialOrderInfo(
    struct: TwapStruct,
  ): Pick<
    TwapOrderInfo,
    | 'kind'
    | 'class'
    | 'sellAmount'
    | 'buyAmount'
    | 'startTime'
    | 'numberOfParts'
    | 'timeBetweenParts'
    | 'durationOfPart'
  > {
    const {
      n: numberOfParts,
      partSellAmount,
      minPartLimit,
      t: timeBetweenParts,
      t0: startEpoch,
      span,
    } = struct;

    const sellAmount = partSellAmount * numberOfParts;
    const buyAmount = minPartLimit * numberOfParts;

    const isSpanZero = Number(span) === 0;
    const durationOfPart: DurationOfPart = isSpanZero
      ? { durationType: DurationType.Auto }
      : { durationType: DurationType.LimitDuration, duration: span.toString() };

    const startTime: StartTime = isSpanZero
      ? { startType: StartTimeValue.AtMiningTime }
      : { startType: StartTimeValue.AtEpoch, epoch: Number(startEpoch) };

    return {
      kind: OrderKind.Sell,
      class: OrderClass.Limit,
      sellAmount: sellAmount.toString(),
      buyAmount: buyAmount.toString(),
      startTime,
      numberOfParts: numberOfParts.toString(),
      timeBetweenParts: Number(timeBetweenParts),
      durationOfPart,
    };
  }

  /**
   * Generates TWAP order parts based on the given TWAP struct and its execution date.
   *
   * @param args.twapStruct - {@link TwapStruct} (decoded `staticInput` of `createWithContext`)
   * @param args.executionDate - date of the TWAP execution
   * @param args.chainId - chain ID of the TWAP
   * @returns array of {@link GPv2OrderParameters} that represent the TWAP order parts
   *
   * Implementation based on CoW Swap app
   * @see https://github.com/cowprotocol/cowswap/blob/1cdfa24c6448e3ebf2c6e3c986cb5d7bfd269aa4/apps/cowswap-frontend/src/modules/twap/updaters/PartOrdersUpdater.tsx#L44
   */
  public generateTwapOrderParts(args: {
    twapStruct: TwapStruct;
    executionDate: Date;
    chainId: string;
  }): Array<GPv2OrderParameters> {
    return Array.from({ length: Number(args.twapStruct.n) }, (_, index) => {
      return {
        sellToken: args.twapStruct.sellToken,
        buyToken: args.twapStruct.buyToken,
        receiver: args.twapStruct.receiver,
        sellAmount: args.twapStruct.partSellAmount,
        buyAmount: args.twapStruct.minPartLimit,
        validTo: this.calculateValidTo({
          part: index,
          startTime: Math.ceil(args.executionDate.getTime() / 1_000),
          span: Number(args.twapStruct.span),
          frequency: Number(args.twapStruct.t),
        }),
        appData: args.twapStruct.appData,
        feeAmount: BigInt('0'),
        kind: OrderKind.Sell,
        partiallyFillable: false,
        sellTokenBalance: SellTokenBalance.Erc20,
        buyTokenBalance: BuyTokenBalance.Erc20,
      };
    });
  }

  /**
   * Checks if the app associated contained in fullAppData is allowed.
   *
   * @param fullAppData - object to which we should verify the app data with
   * @returns true if the app is allowed, false otherwise.
   */
  public isAppAllowed(fullAppData: FullAppData): boolean {
    if (!this.restrictApps) return true;
    const appCode = fullAppData.fullAppData?.appCode;
    return (
      !!appCode && typeof appCode === 'string' && this.allowedApps.has(appCode)
    );
  }

  private calculateValidTo(args: {
    part: number;
    startTime: number;
    frequency: number;
    span: number;
  }): number {
    const validityPeriod =
      args.span === 0
        ? (args.part + 1) * args.frequency - 1
        : args.part * args.frequency + args.span - 1;

    return args.startTime + validityPeriod;
  }
}

function allowedAppsFactory(
  configurationService: IConfigurationService,
): Set<string> {
  const allowedApps =
    configurationService.getOrThrow<string[]>('swaps.allowedApps');
  return new Set(allowedApps);
}

@Module({
  imports: [],
  providers: [
    ComposableCowDecoder,
    MultiSendDecoder,
    TwapOrderHelper,
    {
      provide: 'SWAP_ALLOWED_APPS',
      useFactory: allowedAppsFactory,
      inject: [IConfigurationService],
    },
  ],
  exports: [TwapOrderHelper],
})
export class TwapOrderHelperModule {}

1	import { MultiSendDecoder } from '@/domain/contracts/decoders/multi-send-decoder.helper';	16✔
2	import {	16✔
3	ComposableCowDecoder,
4	TwapStruct,
5	} from '@/domain/swaps/contracts/decoders/composable-cow-decoder.helper';
6	import {	16✔
7	BuyTokenBalance,
8	OrderClass,
9	OrderKind,
10	SellTokenBalance,
11	} from '@/domain/swaps/entities/order.entity';
12	import {	16✔
13	DurationType,
14	StartTimeValue,
15	DurationOfPart,
16	StartTime,
17	TwapOrderInfo,
18	} from '@/routes/transactions/entities/swaps/twap-order-info.entity';
19	import { GPv2OrderParameters } from '@/domain/swaps/contracts/decoders/gp-v2-decoder.helper';
20	import { Inject, Injectable, Module } from '@nestjs/common';	16✔
21	import { isAddressEqual } from 'viem';	16✔
22	import { IConfigurationService } from '@/config/configuration.service.interface';	16✔
23	import { FullAppData } from '@/domain/swaps/entities/full-app-data.entity';
24
25	/**
26	*
27	* @see https://github.com/cowprotocol/contracts/blob/1465e69f6935b3ef9ce45d4878e44f0335ef8531/src/ts/order.ts
28	*/
29	@Injectable()
30	export class TwapOrderHelper {	16✔
31	private static readonly ComposableCowAddress =	16✔
32	'0xfdaFc9d1902f4e0b84f65F49f244b32b31013b74' as const;
33
34	private readonly restrictApps: boolean;
35
36	constructor(
37	@Inject(IConfigurationService)
38	private readonly configurationService: IConfigurationService,	16✔
39	private readonly multiSendDecoder: MultiSendDecoder,	16✔
40	private readonly composableCowDecoder: ComposableCowDecoder,	16✔
41	@Inject('SWAP_ALLOWED_APPS') private readonly allowedApps: Set<string>,	16✔
42	) {
43	this.restrictApps =	16✔
44	this.configurationService.getOrThrow<boolean>('swaps.restrictApps');
45	}
46
47	// TODO: Refactor findSwapOrder, findSwapTransfer and findTwapOrder to avoid code duplication
48
49	/**
50	* Finds a TWAP order in a given transaction, either directly called or in a MultiSend
51	*
52	* @param args.to - recipient of the transaction
53	* @param args.data - data of the transaction
54	* @returns TWAP order data if found, otherwise null
55	*/
56	public findTwapOrder(args: {
57	to: `0x${string}`;
58	data: `0x${string}`;
59	}): `0x${string}` \| null {
60	if (this.isTwapOrder(args)) {	×
61	return args.data;	×
62	}
63
64	if (this.multiSendDecoder.helpers.isMultiSend(args.data)) {	×
65	const transactions = this.multiSendDecoder.mapMultiSendTransactions(	×
66	args.data,
67	);
68
69	for (const transaction of transactions) {	×
70	if (this.isTwapOrder(transaction)) {	×
71	return transaction.data;	×
72	}
73	}
74	}
75
76	return null;	×
77	}
78
79	private isTwapOrder(args: {
80	to: `0x${string}`;
81	data: `0x${string}`;
82	}): boolean {
83	return (	×
84	isAddressEqual(args.to, TwapOrderHelper.ComposableCowAddress) &&	×
85	this.composableCowDecoder.helpers.isCreateWithContext(args.data)
86	);
87	}
88
89	/**
90	* Maps values of {@link TwapStruct} to partial {@link TwapOrderInfo}
91	*
92	* @param struct - {@link TwapStruct} to map
93	* @returns partial mapping of {@link TwapOrderInfo}
94	*/
95	public twapStructToPartialOrderInfo(
96	struct: TwapStruct,
97	): Pick<
98	TwapOrderInfo,
99	\| 'kind'
100	\| 'class'
101	\| 'sellAmount'
102	\| 'buyAmount'
103	\| 'startTime'
104	\| 'numberOfParts'
105	\| 'timeBetweenParts'
106	\| 'durationOfPart'
107	> {
108	const {
109	n: numberOfParts,
110	partSellAmount,
111	minPartLimit,
112	t: timeBetweenParts,
113	t0: startEpoch,
114	span,
115	} = struct;	×
116
117	const sellAmount = partSellAmount * numberOfParts;	×
118	const buyAmount = minPartLimit * numberOfParts;	×
119
120	const isSpanZero = Number(span) === 0;	×
121	const durationOfPart: DurationOfPart = isSpanZero	×
122	? { durationType: DurationType.Auto }
123	: { durationType: DurationType.LimitDuration, duration: span.toString() };
124
125	const startTime: StartTime = isSpanZero	×
126	? { startType: StartTimeValue.AtMiningTime }
127	: { startType: StartTimeValue.AtEpoch, epoch: Number(startEpoch) };
128
129	return {	×
130	kind: OrderKind.Sell,
131	class: OrderClass.Limit,
132	sellAmount: sellAmount.toString(),
133	buyAmount: buyAmount.toString(),
134	startTime,
135	numberOfParts: numberOfParts.toString(),
136	timeBetweenParts: Number(timeBetweenParts),
137	durationOfPart,
138	};
139	}
140
141	/**
142	* Generates TWAP order parts based on the given TWAP struct and its execution date.
143	*
144	* @param args.twapStruct - {@link TwapStruct} (decoded `staticInput` of `createWithContext`)
145	* @param args.executionDate - date of the TWAP execution
146	* @param args.chainId - chain ID of the TWAP
147	* @returns array of {@link GPv2OrderParameters} that represent the TWAP order parts
148	*
149	* Implementation based on CoW Swap app
150	* @see https://github.com/cowprotocol/cowswap/blob/1cdfa24c6448e3ebf2c6e3c986cb5d7bfd269aa4/apps/cowswap-frontend/src/modules/twap/updaters/PartOrdersUpdater.tsx#L44
151	*/
152	public generateTwapOrderParts(args: {
153	twapStruct: TwapStruct;
154	executionDate: Date;
155	chainId: string;
156	}): Array<GPv2OrderParameters> {
157	return Array.from({ length: Number(args.twapStruct.n) }, (_, index) => {	×
158	return {	×
159	sellToken: args.twapStruct.sellToken,
160	buyToken: args.twapStruct.buyToken,
161	receiver: args.twapStruct.receiver,
162	sellAmount: args.twapStruct.partSellAmount,
163	buyAmount: args.twapStruct.minPartLimit,
164	validTo: this.calculateValidTo({
165	part: index,
166	startTime: Math.ceil(args.executionDate.getTime() / 1_000),
167	span: Number(args.twapStruct.span),
168	frequency: Number(args.twapStruct.t),
169	}),
170	appData: args.twapStruct.appData,
171	feeAmount: BigInt('0'),
172	kind: OrderKind.Sell,
173	partiallyFillable: false,
174	sellTokenBalance: SellTokenBalance.Erc20,
175	buyTokenBalance: BuyTokenBalance.Erc20,
176	};
177	});
178	}
179
180	/**
181	* Checks if the app associated contained in fullAppData is allowed.
182	*
183	* @param fullAppData - object to which we should verify the app data with
184	* @returns true if the app is allowed, false otherwise.
185	*/
186	public isAppAllowed(fullAppData: FullAppData): boolean {
NEW 187	if (!this.restrictApps) return true;	×
NEW 188	const appCode = fullAppData.fullAppData?.appCode;	×
NEW 189	return (	×
190	!!appCode && typeof appCode === 'string' && this.allowedApps.has(appCode)	×
191	);
192	}
193
194	private calculateValidTo(args: {
195	part: number;
196	startTime: number;
197	frequency: number;
198	span: number;
199	}): number {
200	const validityPeriod =
201	args.span === 0	×
202	? (args.part + 1) * args.frequency - 1
203	: args.part * args.frequency + args.span - 1;
204
205	return args.startTime + validityPeriod;	×
206	}
207	}
208
209	function allowedAppsFactory(
210	configurationService: IConfigurationService,
211	): Set<string> {
212	const allowedApps =
213	configurationService.getOrThrow<string[]>('swaps.allowedApps');	16✔
214	return new Set(allowedApps);	16✔
215	}
216
217	@Module({
218	imports: [],
219	providers: [
220	ComposableCowDecoder,
221	MultiSendDecoder,
222	TwapOrderHelper,
223	{
224	provide: 'SWAP_ALLOWED_APPS',
225	useFactory: allowedAppsFactory,
226	inject: [IConfigurationService],
227	},
228	],
229	exports: [TwapOrderHelper],
230	})
231	export class TwapOrderHelperModule {}	16✔

safe-global / safe-client-gateway / 9796547219

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