11326190885

Committed 14 Oct 2024 11:01AM UTC coverage: 91.782% (-0.01%) from 91.795%

Build # 11326190885

Build Type

Pull #2011

github

Committed by

iamacook

Commit Message

Enable `no-nested-ternary` lint rule

Pull Request Pull Request #2011: Enable `no-nested-ternary` lint rule

Run Details

2603 of 3167 branches covered (82.19%)

Branch coverage included in aggregate %.

7 of 7 new or added lines in 1 file covered. (100.0%)

2 existing lines in 1 file now uncovered.

8699 of 9147 relevant lines covered (95.1%)

417.89 hits per line

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

90.48

/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 no parts if transaction isn't executed, otherwise only those up to max
    const partsToFetch = ((): Array<GPv2OrderParameters> => {
      if (!transaction.executionDate) {
        return [];
      }
      if (!hasAbundantParts) {
        return twapParts;
      }
      // 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
      return twapParts.slice(-1);
    })();

    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;
    }

    const finalPart = args.twapParts.slice(-1)[0];
    const finalOrderUid = this.gpv2OrderHelper.computeOrderUid({
      chainId: args.chainId,
      owner: args.safeAddress,
      order: finalPart,
    });

    // Check active or final order order
    const orderUidToCheck = args.activeOrderUid ?? finalOrderUid;

    try {
      // If already fetched (and exists), we don't need fetch it again
      const orderAlreadyFetched = args.partOrders?.find((order) => {
        return order.uid === orderUidToCheck;
      });
      if (!orderAlreadyFetched) {
        // Check if we can get the order (if it "exists")
        await this.swapsRepository.getOrder(args.chainId, orderUidToCheck);
      }

      // We successfully fetched the final order OR the active order matches
      // that of the final order meaning that the final order was created and
      // we therefore know the TWAP was fulfilled
      // Note: the final order of a TWAP can expire but as it would inherently
      // be partially filled, we consider expired final orders as fulfilled
      if (!args.activeOrderUid || args.activeOrderUid === finalOrderUid) {
        return OrderStatus.Fulfilled;
      }

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

safe-global / safe-client-gateway / 11326190885

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