10672898499

Committed 02 Sep 2024 08:53PM UTC coverage: 45.988% (-0.3%) from 46.327%

Build # 10672898499

Build Type

Pull #1882

github

Committed by

hectorgomezv

Commit Message

Extract ValidatorsExit confirmation view unit tests

Pull Request Pull Request #1882: Add Native Staking Withdraw transaction mappings

Run Details

499 of 3160 branches covered (15.79%)

Branch coverage included in aggregate %.

26 of 81 new or added lines in 11 files covered. (32.1%)

1 existing line in 1 file now uncovered.

4837 of 8443 relevant lines covered (57.29%)

12.18 hits per line

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

13.19

/src/routes/transactions/transactions-view.service.ts

import { IConfigurationService } from '@/config/configuration.service.interface';
import { IDataDecodedRepository } from '@/domain/data-decoder/data-decoded.repository.interface';
import { DataDecoded } from '@/domain/data-decoder/entities/data-decoded.entity';
import { ComposableCowDecoder } from '@/domain/swaps/contracts/decoders/composable-cow-decoder.helper';
import { GPv2Decoder } from '@/domain/swaps/contracts/decoders/gp-v2-decoder.helper';
import { OrderStatus } from '@/domain/swaps/entities/order.entity';
import { ISwapsRepository } from '@/domain/swaps/swaps.repository';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { TransactionDataDto } from '@/routes/common/entities/transaction-data.dto.entity';
import {
  BaselineConfirmationView,
  ConfirmationView,
  CowSwapConfirmationView,
  CowSwapTwapConfirmationView,
} from '@/routes/transactions/entities/confirmation-view/confirmation-view.entity';
import { NativeStakingDepositConfirmationView } from '@/routes/transactions/entities/staking/native-staking-deposit-confirmation-view.entity';
import { NativeStakingValidatorsExitConfirmationView } from '@/routes/transactions/entities/staking/native-staking-validators-exit-confirmation-view.entity';
import { NativeStakingWithdrawConfirmationView } from '@/routes/transactions/entities/staking/native-staking-withdraw-confirmation-view.entity';
import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';
import { KilnNativeStakingHelper } from '@/routes/transactions/helpers/kiln-native-staking.helper';
import { SwapAppsHelper } from '@/routes/transactions/helpers/swap-apps.helper';
import { SwapOrderHelper } from '@/routes/transactions/helpers/swap-order.helper';
import { TwapOrderHelper } from '@/routes/transactions/helpers/twap-order.helper';
import { NativeStakingMapper } from '@/routes/transactions/mappers/common/native-staking.mapper';
import { Inject, Injectable } from '@nestjs/common';

@Injectable({})
export class TransactionsViewService {
  private readonly isNativeStakingEnabled: boolean;

  constructor(
    @Inject(IDataDecodedRepository)
    private readonly dataDecodedRepository: IDataDecodedRepository,
    private readonly gpv2Decoder: GPv2Decoder,
    private readonly swapOrderHelper: SwapOrderHelper,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
    private readonly twapOrderHelper: TwapOrderHelper,
    @Inject(ISwapsRepository)
    private readonly swapsRepository: ISwapsRepository,
    private readonly composableCowDecoder: ComposableCowDecoder,
    private readonly swapAppsHelper: SwapAppsHelper,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    private readonly kilnNativeStakingHelper: KilnNativeStakingHelper,
    private readonly nativeStakingMapper: NativeStakingMapper,
  ) {
    this.isNativeStakingEnabled = this.configurationService.getOrThrow<boolean>(
      'features.nativeStaking',
    );
  }

  async getTransactionConfirmationView(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    transactionDataDto: TransactionDataDto;
  }): Promise<ConfirmationView> {
    const dataDecoded = await this.dataDecodedRepository
      .getDataDecoded({
        chainId: args.chainId,
        data: args.transactionDataDto.data,
        to: args.transactionDataDto.to,
      })
      .catch(() => {
        // TODO: Get Kiln to verify all deployments
        // Fallback for unverified contracts
        return {
          method: '',
          parameters: null,
        };
      });

    const swapOrderData = this.swapOrderHelper.findSwapOrder(
      args.transactionDataDto.data,
    );

    const twapSwapOrderData = args.transactionDataDto.to
      ? this.twapOrderHelper.findTwapOrder({
          to: args.transactionDataDto.to,
          data: args.transactionDataDto.data,
        })
      : null;

    const nativeStakingDepositTransaction =
      this.isNativeStakingEnabled &&
      (await this.kilnNativeStakingHelper.findDeposit({
        chainId: args.chainId,
        ...args.transactionDataDto,
      }));

    const nativeStakingValidatorsExitTransaction =
      this.isNativeStakingEnabled &&
      (await this.kilnNativeStakingHelper.findValidatorsExit({
        chainId: args.chainId,
        ...args.transactionDataDto,
      }));

    const nativeStakingWithdrawTransaction =
      this.isNativeStakingEnabled &&
      (await this.kilnNativeStakingHelper.findWithdraw({
        chainId: args.chainId,
        ...args.transactionDataDto,
      }));

    if (
      !swapOrderData &&
      !twapSwapOrderData &&
      !nativeStakingDepositTransaction &&
      !nativeStakingValidatorsExitTransaction &&
      !nativeStakingWithdrawTransaction
    ) {
      return new BaselineConfirmationView({
        method: dataDecoded.method,
        parameters: dataDecoded.parameters,
      });
    }

    try {
      if (swapOrderData) {
        return await this.getSwapOrderConfirmationView({
          chainId: args.chainId,
          data: swapOrderData,
          dataDecoded,
        });
      } else if (twapSwapOrderData) {
        return await this.getTwapOrderConfirmationView({
          chainId: args.chainId,
          safeAddress: args.safeAddress,
          data: twapSwapOrderData,
          dataDecoded,
        });
      } else if (nativeStakingDepositTransaction) {
        return await this.getNativeStakingDepositConfirmationView({
          ...nativeStakingDepositTransaction,
          chainId: args.chainId,
          dataDecoded,
          value: args.transactionDataDto.value ?? null,
        });
      } else if (nativeStakingValidatorsExitTransaction) {
        return await this.getNativeStakingValidatorsExitConfirmationView({
          ...nativeStakingValidatorsExitTransaction,
          chainId: args.chainId,
          dataDecoded,
          value: args.transactionDataDto.value ?? null,
        });
      } else if (nativeStakingWithdrawTransaction) {
        return await this.getNativeStakingWithdrawConfirmationView({
          ...nativeStakingWithdrawTransaction,
          chainId: args.chainId,
          dataDecoded,
          value: args.transactionDataDto.value ?? null,
        });
      } else {
        // Should not reach here
        throw new Error('No swap order data found');
      }
    } catch (error) {
      this.loggingService.warn(error);
      return new BaselineConfirmationView({
        method: dataDecoded.method,
        parameters: dataDecoded.parameters,
      });
    }
  }

  private async getSwapOrderConfirmationView(args: {
    chainId: string;
    data: `0x${string}`;
    dataDecoded: DataDecoded;
  }): Promise<CowSwapConfirmationView> {
    const orderUid: `0x${string}` | null =
      this.gpv2Decoder.getOrderUidFromSetPreSignature(args.data);
    if (!orderUid) {
      throw new Error('Order UID not found in transaction data');
    }

    const order = await this.swapOrderHelper.getOrder({
      chainId: args.chainId,
      orderUid,
    });

    if (!this.swapAppsHelper.isAppAllowed(order)) {
      throw new Error(`Unsupported App: ${order.fullAppData?.appCode}`);
    }

    const [sellToken, buyToken] = await Promise.all([
      this.swapOrderHelper.getToken({
        chainId: args.chainId,
        address: order.sellToken,
      }),
      this.swapOrderHelper.getToken({
        chainId: args.chainId,
        address: order.buyToken,
      }),
    ]);

    return new CowSwapConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      uid: order.uid,
      status: order.status,
      kind: order.kind,
      orderClass: order.class,
      validUntil: order.validTo,
      sellAmount: order.sellAmount.toString(),
      buyAmount: order.buyAmount.toString(),
      executedSellAmount: order.executedSellAmount.toString(),
      executedBuyAmount: order.executedBuyAmount.toString(),
      explorerUrl: this.swapOrderHelper.getOrderExplorerUrl(order).toString(),
      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,
      }),
      executedSurplusFee: order.executedSurplusFee?.toString() ?? null,
      receiver: order.receiver,
      owner: order.owner,
      fullAppData: order.fullAppData,
    });
  }

  private async getTwapOrderConfirmationView(args: {
    chainId: string;
    safeAddress: `0x${string}`;
    data: `0x${string}`;
    dataDecoded: DataDecoded;
  }): Promise<CowSwapTwapConfirmationView> {
    // Decode `staticInput` of `createWithContextCall`
    const twapStruct = this.composableCowDecoder.decodeTwapStruct(args.data);
    const twapOrderData =
      this.twapOrderHelper.twapStructToPartialOrderInfo(twapStruct);

    // Generate parts of the TWAP order
    const twapParts = this.twapOrderHelper.generateTwapOrderParts({
      twapStruct,
      executionDate: new Date(),
      chainId: args.chainId,
    });

    // Decode hash of `appData`
    const fullAppData = await this.swapsRepository.getFullAppData(
      args.chainId,
      twapStruct.appData,
    );

    if (!this.swapAppsHelper.isAppAllowed(fullAppData)) {
      throw new Error(`Unsupported App: ${fullAppData.fullAppData?.appCode}`);
    }

    const [buyToken, sellToken] = await Promise.all([
      this.swapOrderHelper.getToken({
        chainId: args.chainId,
        address: twapStruct.buyToken,
      }),
      this.swapOrderHelper.getToken({
        chainId: args.chainId,
        address: twapStruct.sellToken,
      }),
    ]);

    return new CowSwapTwapConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      status: OrderStatus.PreSignaturePending,
      kind: twapOrderData.kind,
      class: twapOrderData.class,
      activeOrderUid: null,
      validUntil: Math.max(...twapParts.map((order) => order.validTo)),
      sellAmount: twapOrderData.sellAmount,
      buyAmount: twapOrderData.buyAmount,
      executedSellAmount: '0',
      executedBuyAmount: '0',
      executedSurplusFee: '0',
      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: args.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 async getNativeStakingDepositConfirmationView(args: {
    chainId: string;
    to: `0x${string}`;
    data: `0x${string}`;
    dataDecoded: DataDecoded;
    value: string | null;
  }): Promise<NativeStakingDepositConfirmationView> {
    const depositInfo = await this.nativeStakingMapper.mapDepositInfo({
      chainId: args.chainId,
      to: args.to,
      value: args.value,
      isConfirmed: false,
      depositExecutionDate: null,
    });
    return new NativeStakingDepositConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      ...depositInfo,
    });
  }

  private async getNativeStakingValidatorsExitConfirmationView(args: {
    chainId: string;
    to: `0x${string}`;
    data: `0x${string}`;
    dataDecoded: DataDecoded;
    value: string | null;
  }): Promise<NativeStakingValidatorsExitConfirmationView> {
    const validatorsExitInfo =
      await this.nativeStakingMapper.mapValidatorsExitInfo({
        chainId: args.chainId,
        to: args.to,
        value: args.value,
        transaction: null,
      });
    return new NativeStakingValidatorsExitConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      ...validatorsExitInfo,
    });
  }

  private async getNativeStakingWithdrawConfirmationView(args: {
    chainId: string;
    to: `0x${string}`;
    data: `0x${string}`;
    dataDecoded: DataDecoded;
    value: string | null;
  }): Promise<NativeStakingWithdrawConfirmationView> {
    const withdrawInfo = await this.nativeStakingMapper.mapWithdrawInfo({
      chainId: args.chainId,
      to: args.to,
      value: args.value,
      transaction: null,
    });
    return new NativeStakingWithdrawConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      ...withdrawInfo,
    });
  }
}

1	import { IConfigurationService } from '@/config/configuration.service.interface';	16✔
2	import { IDataDecodedRepository } from '@/domain/data-decoder/data-decoded.repository.interface';	16✔
3	import { DataDecoded } from '@/domain/data-decoder/entities/data-decoded.entity';
4	import { ComposableCowDecoder } from '@/domain/swaps/contracts/decoders/composable-cow-decoder.helper';	16✔
5	import { GPv2Decoder } from '@/domain/swaps/contracts/decoders/gp-v2-decoder.helper';	16✔
6	import { OrderStatus } from '@/domain/swaps/entities/order.entity';	16✔
7	import { ISwapsRepository } from '@/domain/swaps/swaps.repository';	16✔
8	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	16✔
9	import { TransactionDataDto } from '@/routes/common/entities/transaction-data.dto.entity';
10	import {	16✔
11	BaselineConfirmationView,
12	ConfirmationView,
13	CowSwapConfirmationView,
14	CowSwapTwapConfirmationView,
15	} from '@/routes/transactions/entities/confirmation-view/confirmation-view.entity';
16	import { NativeStakingDepositConfirmationView } from '@/routes/transactions/entities/staking/native-staking-deposit-confirmation-view.entity';	16✔
17	import { NativeStakingValidatorsExitConfirmationView } from '@/routes/transactions/entities/staking/native-staking-validators-exit-confirmation-view.entity';	16✔
18	import { NativeStakingWithdrawConfirmationView } from '@/routes/transactions/entities/staking/native-staking-withdraw-confirmation-view.entity';	16✔
19	import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';	16✔
20	import { KilnNativeStakingHelper } from '@/routes/transactions/helpers/kiln-native-staking.helper';	16✔
21	import { SwapAppsHelper } from '@/routes/transactions/helpers/swap-apps.helper';	16✔
22	import { SwapOrderHelper } from '@/routes/transactions/helpers/swap-order.helper';	16✔
23	import { TwapOrderHelper } from '@/routes/transactions/helpers/twap-order.helper';	16✔
24	import { NativeStakingMapper } from '@/routes/transactions/mappers/common/native-staking.mapper';	16✔
25	import { Inject, Injectable } from '@nestjs/common';	16✔
26
27	@Injectable({})
28	export class TransactionsViewService {	16✔
29	private readonly isNativeStakingEnabled: boolean;
30
31	constructor(
32	@Inject(IDataDecodedRepository)
33	private readonly dataDecodedRepository: IDataDecodedRepository,	×
34	private readonly gpv2Decoder: GPv2Decoder,	×
35	private readonly swapOrderHelper: SwapOrderHelper,	×
36	@Inject(LoggingService) private readonly loggingService: ILoggingService,	×
37	private readonly twapOrderHelper: TwapOrderHelper,	×
38	@Inject(ISwapsRepository)
39	private readonly swapsRepository: ISwapsRepository,	×
40	private readonly composableCowDecoder: ComposableCowDecoder,	×
41	private readonly swapAppsHelper: SwapAppsHelper,	×
42	@Inject(IConfigurationService)
43	private readonly configurationService: IConfigurationService,	×
44	private readonly kilnNativeStakingHelper: KilnNativeStakingHelper,	×
45	private readonly nativeStakingMapper: NativeStakingMapper,	×
46	) {
47	this.isNativeStakingEnabled = this.configurationService.getOrThrow<boolean>(	×
48	'features.nativeStaking',
49	);
50	}
51
52	async getTransactionConfirmationView(args: {
53	chainId: string;
54	safeAddress: `0x${string}`;
55	transactionDataDto: TransactionDataDto;
56	}): Promise<ConfirmationView> {
57	const dataDecoded = await this.dataDecodedRepository	×
58	.getDataDecoded({
59	chainId: args.chainId,
60	data: args.transactionDataDto.data,
61	to: args.transactionDataDto.to,
62	})
63	.catch(() => {
64	// TODO: Get Kiln to verify all deployments
65	// Fallback for unverified contracts
66	return {	×
67	method: '',
68	parameters: null,
69	};
70	});
71
72	const swapOrderData = this.swapOrderHelper.findSwapOrder(	×
73	args.transactionDataDto.data,
74	);
75
76	const twapSwapOrderData = args.transactionDataDto.to	×
77	? this.twapOrderHelper.findTwapOrder({
78	to: args.transactionDataDto.to,
79	data: args.transactionDataDto.data,
80	})
81	: null;
82
83	const nativeStakingDepositTransaction =
84	this.isNativeStakingEnabled &&	×
85	(await this.kilnNativeStakingHelper.findDeposit({
86	chainId: args.chainId,
87	...args.transactionDataDto,
88	}));
89
90	const nativeStakingValidatorsExitTransaction =
91	this.isNativeStakingEnabled &&	×
92	(await this.kilnNativeStakingHelper.findValidatorsExit({
93	chainId: args.chainId,
94	...args.transactionDataDto,
95	}));
96
97	const nativeStakingWithdrawTransaction =
NEW 98	this.isNativeStakingEnabled &&	×
99	(await this.kilnNativeStakingHelper.findWithdraw({
100	chainId: args.chainId,
101	...args.transactionDataDto,
102	}));
103
UNCOV 104	if (	×
105	!swapOrderData &&	×
106	!twapSwapOrderData &&
107	!nativeStakingDepositTransaction &&
108	!nativeStakingValidatorsExitTransaction &&
109	!nativeStakingWithdrawTransaction
110	) {
111	return new BaselineConfirmationView({	×
112	method: dataDecoded.method,
113	parameters: dataDecoded.parameters,
114	});
115	}
116
117	try {	×
118	if (swapOrderData) {	×
119	return await this.getSwapOrderConfirmationView({	×
120	chainId: args.chainId,
121	data: swapOrderData,
122	dataDecoded,
123	});
124	} else if (twapSwapOrderData) {	×
125	return await this.getTwapOrderConfirmationView({	×
126	chainId: args.chainId,
127	safeAddress: args.safeAddress,
128	data: twapSwapOrderData,
129	dataDecoded,
130	});
131	} else if (nativeStakingDepositTransaction) {	×
132	return await this.getNativeStakingDepositConfirmationView({	×
133	...nativeStakingDepositTransaction,
134	chainId: args.chainId,
135	dataDecoded,
136	value: args.transactionDataDto.value ?? null,	×
137	});
138	} else if (nativeStakingValidatorsExitTransaction) {	×
139	return await this.getNativeStakingValidatorsExitConfirmationView({	×
140	...nativeStakingValidatorsExitTransaction,
141	chainId: args.chainId,
142	dataDecoded,
143	value: args.transactionDataDto.value ?? null,	×
144	});
NEW 145	} else if (nativeStakingWithdrawTransaction) {	×
NEW 146	return await this.getNativeStakingWithdrawConfirmationView({	×
147	...nativeStakingWithdrawTransaction,
148	chainId: args.chainId,
149	dataDecoded,
150	value: args.transactionDataDto.value ?? null,	×
151	});
152	} else {
153	// Should not reach here
154	throw new Error('No swap order data found');	×
155	}
156	} catch (error) {
157	this.loggingService.warn(error);	×
158	return new BaselineConfirmationView({	×
159	method: dataDecoded.method,
160	parameters: dataDecoded.parameters,
161	});
162	}
163	}
164
165	private async getSwapOrderConfirmationView(args: {
166	chainId: string;
167	data: `0x${string}`;
168	dataDecoded: DataDecoded;
169	}): Promise<CowSwapConfirmationView> {
170	const orderUid: `0x${string}` \| null =
171	this.gpv2Decoder.getOrderUidFromSetPreSignature(args.data);	×
172	if (!orderUid) {	×
173	throw new Error('Order UID not found in transaction data');	×
174	}
175
176	const order = await this.swapOrderHelper.getOrder({	×
177	chainId: args.chainId,
178	orderUid,
179	});
180
181	if (!this.swapAppsHelper.isAppAllowed(order)) {	×
182	throw new Error(`Unsupported App: ${order.fullAppData?.appCode}`);	×
183	}
184
185	const [sellToken, buyToken] = await Promise.all([	×
186	this.swapOrderHelper.getToken({
187	chainId: args.chainId,
188	address: order.sellToken,
189	}),
190	this.swapOrderHelper.getToken({
191	chainId: args.chainId,
192	address: order.buyToken,
193	}),
194	]);
195
196	return new CowSwapConfirmationView({	×
197	method: args.dataDecoded.method,
198	parameters: args.dataDecoded.parameters,
199	uid: order.uid,
200	status: order.status,
201	kind: order.kind,
202	orderClass: order.class,
203	validUntil: order.validTo,
204	sellAmount: order.sellAmount.toString(),
205	buyAmount: order.buyAmount.toString(),
206	executedSellAmount: order.executedSellAmount.toString(),
207	executedBuyAmount: order.executedBuyAmount.toString(),
208	explorerUrl: this.swapOrderHelper.getOrderExplorerUrl(order).toString(),
209	sellToken: new TokenInfo({
210	address: sellToken.address,
211	decimals: sellToken.decimals,
212	logoUri: sellToken.logoUri,
213	name: sellToken.name,
214	symbol: sellToken.symbol,
215	trusted: sellToken.trusted,
216	}),
217	buyToken: new TokenInfo({
218	address: buyToken.address,
219	decimals: buyToken.decimals,
220	logoUri: buyToken.logoUri,
221	name: buyToken.name,
222	symbol: buyToken.symbol,
223	trusted: buyToken.trusted,
224	}),
225	executedSurplusFee: order.executedSurplusFee?.toString() ?? null,	×
226	receiver: order.receiver,
227	owner: order.owner,
228	fullAppData: order.fullAppData,
229	});
230	}
231
232	private async getTwapOrderConfirmationView(args: {
233	chainId: string;
234	safeAddress: `0x${string}`;
235	data: `0x${string}`;
236	dataDecoded: DataDecoded;
237	}): Promise<CowSwapTwapConfirmationView> {
238	// Decode `staticInput` of `createWithContextCall`
239	const twapStruct = this.composableCowDecoder.decodeTwapStruct(args.data);	×
240	const twapOrderData =
241	this.twapOrderHelper.twapStructToPartialOrderInfo(twapStruct);	×
242
243	// Generate parts of the TWAP order
244	const twapParts = this.twapOrderHelper.generateTwapOrderParts({	×
245	twapStruct,
246	executionDate: new Date(),
247	chainId: args.chainId,
248	});
249
250	// Decode hash of `appData`
251	const fullAppData = await this.swapsRepository.getFullAppData(	×
252	args.chainId,
253	twapStruct.appData,
254	);
255
256	if (!this.swapAppsHelper.isAppAllowed(fullAppData)) {	×
257	throw new Error(`Unsupported App: ${fullAppData.fullAppData?.appCode}`);	×
258	}
259
260	const [buyToken, sellToken] = await Promise.all([	×
261	this.swapOrderHelper.getToken({
262	chainId: args.chainId,
263	address: twapStruct.buyToken,
264	}),
265	this.swapOrderHelper.getToken({
266	chainId: args.chainId,
267	address: twapStruct.sellToken,
268	}),
269	]);
270
271	return new CowSwapTwapConfirmationView({	×
272	method: args.dataDecoded.method,
273	parameters: args.dataDecoded.parameters,
274	status: OrderStatus.PreSignaturePending,
275	kind: twapOrderData.kind,
276	class: twapOrderData.class,
277	activeOrderUid: null,
278	validUntil: Math.max(...twapParts.map((order) => order.validTo)),	×
279	sellAmount: twapOrderData.sellAmount,
280	buyAmount: twapOrderData.buyAmount,
281	executedSellAmount: '0',
282	executedBuyAmount: '0',
283	executedSurplusFee: '0',
284	sellToken: new TokenInfo({
285	address: sellToken.address,
286	decimals: sellToken.decimals,
287	logoUri: sellToken.logoUri,
288	name: sellToken.name,
289	symbol: sellToken.symbol,
290	trusted: sellToken.trusted,
291	}),
292	buyToken: new TokenInfo({
293	address: buyToken.address,
294	decimals: buyToken.decimals,
295	logoUri: buyToken.logoUri,
296	name: buyToken.name,
297	symbol: buyToken.symbol,
298	trusted: buyToken.trusted,
299	}),
300	receiver: twapStruct.receiver,
301	owner: args.safeAddress,
302	fullAppData: fullAppData.fullAppData,
303	numberOfParts: twapOrderData.numberOfParts,
304	partSellAmount: twapStruct.partSellAmount.toString(),
305	minPartLimit: twapStruct.minPartLimit.toString(),
306	timeBetweenParts: twapOrderData.timeBetweenParts,
307	durationOfPart: twapOrderData.durationOfPart,
308	startTime: twapOrderData.startTime,
309	});
310	}
311
312	private async getNativeStakingDepositConfirmationView(args: {
313	chainId: string;
314	to: `0x${string}`;
315	data: `0x${string}`;
316	dataDecoded: DataDecoded;
317	value: string \| null;
318	}): Promise<NativeStakingDepositConfirmationView> {
319	const depositInfo = await this.nativeStakingMapper.mapDepositInfo({	×
320	chainId: args.chainId,
321	to: args.to,
322	value: args.value,
323	isConfirmed: false,
324	depositExecutionDate: null,
325	});
326	return new NativeStakingDepositConfirmationView({	×
327	method: args.dataDecoded.method,
328	parameters: args.dataDecoded.parameters,
329	...depositInfo,
330	});
331	}
332
333	private async getNativeStakingValidatorsExitConfirmationView(args: {
334	chainId: string;
335	to: `0x${string}`;
336	data: `0x${string}`;
337	dataDecoded: DataDecoded;
338	value: string \| null;
339	}): Promise<NativeStakingValidatorsExitConfirmationView> {
340	const validatorsExitInfo =
341	await this.nativeStakingMapper.mapValidatorsExitInfo({	×
342	chainId: args.chainId,
343	to: args.to,
344	value: args.value,
345	transaction: null,
346	});
347	return new NativeStakingValidatorsExitConfirmationView({	×
348	method: args.dataDecoded.method,
349	parameters: args.dataDecoded.parameters,
350	...validatorsExitInfo,
351	});
352	}
353
354	private async getNativeStakingWithdrawConfirmationView(args: {
355	chainId: string;
356	to: `0x${string}`;
357	data: `0x${string}`;
358	dataDecoded: DataDecoded;
359	value: string \| null;
360	}): Promise<NativeStakingWithdrawConfirmationView> {
NEW 361	const withdrawInfo = await this.nativeStakingMapper.mapWithdrawInfo({	×
362	chainId: args.chainId,
363	to: args.to,
364	value: args.value,
365	transaction: null,
366	});
NEW 367	return new NativeStakingWithdrawConfirmationView({	×
368	method: args.dataDecoded.method,
369	parameters: args.dataDecoded.parameters,
370	...withdrawInfo,
371	});
372	}
373	}

safe-global / safe-client-gateway / 10672898499

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