10093476315

Committed 25 Jul 2024 11:43AM UTC coverage: 48.248% (-0.2%) from 48.454%

Build # 10093476315

Build Type

Pull #1785

github

Committed by

iamacook

Commit Message

Check if active part is final part

Pull Request Pull Request #1785: Improve TWAP order mapping with `activeOrderUid`

Run Details

437 of 2662 branches covered (16.42%)

Branch coverage included in aggregate %.

2 of 44 new or added lines in 3 files covered. (4.55%)

2 existing lines in 2 files now uncovered.

4328 of 7214 relevant lines covered (59.99%)

13.02 hits per line

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

15.24

/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 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

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

    // If active order is final one, it's fulfilled as it exists
    if (args.activeOrderUid === finalOrderUid) {
      return OrderStatus.Fulfilled;
    }

    // Check active or final order part depending on whether the TWAP is active
    const orderUidToCheck = args.activeOrderUid ?? finalOrderUid;

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

      // If the order exists, the TWAP is either open or fulfilled depending
      // on whether the order 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	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 amounts/fees 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 activePart = this.getActivePart({	×
104	twapParts,
105	executionDate: transaction.executionDate,
106	});
107
NEW 108	const activeOrderUid = activePart	×
109	? this.gpv2OrderHelper.computeOrderUid({
110	chainId: chainId,
111	owner: safeAddress,
112	order: activePart,
113	})
114	: null;
115
NEW 116	const partOrders = await this.getPartOrders({	×
117	partsToFetch,
118	chainId,
119	safeAddress,
120	});
121
NEW 122	const status = await this.getOrderStatus({	×
123	chainId,
124	safeAddress,
125	twapParts,
126	partOrders,
127	activeOrderUid,
128	executionDate: transaction.executionDate,
129	});
130
131	const executedSellAmount: TwapOrderInfo['executedSellAmount'] =
NEW 132	hasAbundantParts \|\| !partOrders	×
133	? null
134	: this.getExecutedSellAmount(partOrders).toString();
135
136	const executedBuyAmount: TwapOrderInfo['executedBuyAmount'] =
NEW 137	hasAbundantParts \|\| !partOrders	×
138	? null
139	: this.getExecutedBuyAmount(partOrders).toString();
140
141	const executedSurplusFee: TwapOrderInfo['executedSurplusFee'] =
NEW 142	hasAbundantParts \|\| !partOrders	×
143	? null
144	: this.getExecutedSurplusFee(partOrders).toString();
145
146	const [sellToken, buyToken] = await Promise.all([	×
147	this.swapOrderHelper.getToken({
148	chainId,
149	address: twapStruct.sellToken,
150	}),
151	this.swapOrderHelper.getToken({
152	chainId,
153	address: twapStruct.buyToken,
154	}),
155	]);
156
157	return new TwapOrderTransactionInfo({	×
158	status,
159	kind: twapOrderData.kind,
160	class: twapOrderData.class,
161	activeOrderUid,
UNCOV 162	validUntil: Math.max(...twapParts.map((order) => order.validTo)),	×
163	sellAmount: twapOrderData.sellAmount,
164	buyAmount: twapOrderData.buyAmount,
165	executedSellAmount,
166	executedBuyAmount,
167	executedSurplusFee,
168	sellToken: new TokenInfo({
169	address: sellToken.address,
170	decimals: sellToken.decimals,
171	logoUri: sellToken.logoUri,
172	name: sellToken.name,
173	symbol: sellToken.symbol,
174	trusted: sellToken.trusted,
175	}),
176	buyToken: new TokenInfo({
177	address: buyToken.address,
178	decimals: buyToken.decimals,
179	logoUri: buyToken.logoUri,
180	name: buyToken.name,
181	symbol: buyToken.symbol,
182	trusted: buyToken.trusted,
183	}),
184	receiver: twapStruct.receiver,
185	owner: safeAddress,
186	fullAppData: fullAppData.fullAppData,
187	numberOfParts: twapOrderData.numberOfParts,
188	partSellAmount: twapStruct.partSellAmount.toString(),
189	minPartLimit: twapStruct.minPartLimit.toString(),
190	timeBetweenParts: twapOrderData.timeBetweenParts,
191	durationOfPart: twapOrderData.durationOfPart,
192	startTime: twapOrderData.startTime,
193	});
194	}
195
196	private getActivePart(args: {
197	twapParts: Array<GPv2OrderParameters>;
198	executionDate: Date \| null;
199	}): GPv2OrderParameters \| null {
NEW 200	if (!args.executionDate) {	×
NEW 201	return null;	×
202	}
203
NEW 204	const now = new Date();	×
NEW 205	const activePart = args.twapParts.find((part) => {	×
NEW 206	return part.validTo > Math.floor(now.getTime() / 1_000);	×
207	});
208
NEW 209	return activePart ?? null;	×
210	}
211
212	private async getPartOrders(args: {
213	partsToFetch: Array<GPv2OrderParameters>;
214	chainId: string;
215	safeAddress: `0x${string}`;
216	}): Promise<Array<KnownOrder> \| null> {
NEW 217	const orders: Array<KnownOrder> = [];	×
218
NEW 219	for (const part of args.partsToFetch) {	×
NEW 220	const partFullAppData = await this.swapsRepository.getFullAppData(	×
221	args.chainId,
222	part.appData,
223	);
224
NEW 225	if (!this.swapAppsHelper.isAppAllowed(partFullAppData)) {	×
NEW 226	throw new Error(	×
227	`Unsupported App: ${partFullAppData.fullAppData?.appCode}`,	×
228	);
229	}
230
NEW 231	const orderUid = this.gpv2OrderHelper.computeOrderUid({	×
232	chainId: args.chainId,
233	owner: args.safeAddress,
234	order: part,
235	});
NEW 236	const order = await this.swapsRepository	×
237	.getOrder(args.chainId, orderUid)
238	.catch(() => {
NEW 239	this.loggingService.warn(	×
240	`Error getting orderUid ${orderUid} from SwapsRepository`,
241	);
242	});
243
NEW 244	if (!order \|\| order.kind == OrderKind.Unknown) {	×
245	// Without every order it's not possible to determine executed amounts/fees
NEW 246	return null;	×
247	}
248
NEW 249	if (!this.swapAppsHelper.isAppAllowed(order)) {	×
NEW 250	throw new Error(`Unsupported App: ${order.fullAppData?.appCode}`);	×
251	}
252
NEW 253	orders.push(order as KnownOrder);	×
254	}
255
NEW 256	return orders;	×
257	}
258
259	private async getOrderStatus(args: {
260	chainId: string;
261	safeAddress: `0x${string}`;
262	twapParts: Array<GPv2OrderParameters>;
263	partOrders: Array<KnownOrder> \| null;
264	activeOrderUid: `0x${string}` \| null;
265	executionDate: Date \| null;
266	}): Promise<OrderStatus> {
NEW 267	if (!args.executionDate) {	×
NEW 268	return OrderStatus.PreSignaturePending;	×
269	}
270
271	// Note: TWAPs can never "expire" in their entirety, only parts can but
272	// this does not affect TWAP status
273
NEW 274	const finalOrderUid = this.gpv2OrderHelper.computeOrderUid({	×
275	chainId: args.chainId,
276	owner: args.safeAddress,
277	order: args.twapParts.slice(-1)[0], // Last TWAP part
278	});
279
280	// If active order is final one, it's fulfilled as it exists
NEW 281	if (args.activeOrderUid === finalOrderUid) {	×
NEW 282	return OrderStatus.Fulfilled;	×
283	}
284
285	// Check active or final order part depending on whether the TWAP is active
NEW 286	const orderUidToCheck = args.activeOrderUid ?? finalOrderUid;	×
287
NEW 288	try {	×
289	// If we already fetched the order, we don't need to again
NEW 290	const orderAlreadyFetched = !!args.partOrders?.some(	×
NEW 291	(order) => order.uid === orderUidToCheck,	×
292	);
NEW 293	if (!orderAlreadyFetched) {	×
NEW 294	await this.swapsRepository.getOrder(args.chainId, orderUidToCheck);	×
295	}
296
297	// If the order exists, the TWAP is either open or fulfilled depending
298	// on whether the order is active
NEW 299	return args.activeOrderUid ? OrderStatus.Open : OrderStatus.Fulfilled;	×
300	} catch {
301	// If the order doesn't exist, it means the TWAP was cancelled
NEW 302	return OrderStatus.Cancelled;	×
303	}
304	}
305
306	private getExecutedSellAmount(orders: Array<KnownOrder>): bigint {
307	return orders.reduce((acc, order) => {	×
308	return acc + BigInt(order.executedSellAmount);	×
309	}, BigInt(0));
310	}
311
312	private getExecutedBuyAmount(orders: Array<KnownOrder>): bigint {
313	return orders.reduce((acc, order) => {	×
314	return acc + BigInt(order.executedBuyAmount);	×
315	}, BigInt(0));
316	}
317
318	private getExecutedSurplusFee(orders: Array<KnownOrder>): bigint {
319	return orders.reduce((acc, order) => {	×
320	return acc + BigInt(order.executedSurplusFee ?? BigInt(0));	×
321	}, BigInt(0));
322	}
323	}
324
325	@Module({
326	imports: [
327	SwapOrderHelperModule,
328	SwapsRepositoryModule,
329	SwapOrderMapperModule,
330	TwapOrderHelperModule,
331	SwapAppsHelperModule,
332	],
333	providers: [ComposableCowDecoder, GPv2OrderHelper, TwapOrderMapper],
334	exports: [TwapOrderMapper],
335	})
336	export class TwapOrderMapperModule {}	16✔

safe-global / safe-client-gateway / 10093476315

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