10771607331

Committed 09 Sep 2024 10:43AM UTC coverage: 91.045% (-0.08%) from 91.122%

Build # 10771607331

Build Type

Pull #1903

github

Committed by

hectorgomezv

Commit Message

Add TransctionsViewController tests

Pull Request Pull Request #1903: Add Native Staking transaction data decoders

Run Details

2667 of 3275 branches covered (81.44%)

Branch coverage included in aggregate %.

31 of 42 new or added lines in 3 files covered. (73.81%)

4 existing lines in 1 file now uncovered.

8263 of 8730 relevant lines covered (94.65%)

441.16 hits per line

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

88.96

/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 { KilnDecoder } from '@/domain/staking/contracts/decoders/kiln-decoder.helper';
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,
    private readonly kilnDecoder: KilnDecoder,
  ) {
    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(() => {
        // Fallback for unverified contracts
        const { data } = args.transactionDataDto;
        const fallbackDataDecoded =
          this.kilnDecoder.decodeDeposit(data) ??
          this.kilnDecoder.decodeValidatorsExit(data) ??
          this.kilnDecoder.decodeBatchWithdrawCLFee(data);
        if (!fallbackDataDecoded) {
          throw new Error('Transaction data could not be decoded');
        }
        return fallbackDataDecoded;
      });

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

safe-global / safe-client-gateway / 10771607331

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