10456336577

Committed 19 Aug 2024 03:30PM UTC coverage: 46.252% (-0.6%) from 46.893%

Build # 10456336577

Build Type

Pull #1824

github

Committed by

iamacook

Commit Message

Fix env. var.

Pull Request Pull Request #1824: Staking confirmation screens

Run Details

491 of 3096 branches covered (15.86%)

Branch coverage included in aggregate %.

312 of 650 new or added lines in 35 files covered. (48.0%)

65 existing lines in 2 files now uncovered.

4853 of 8458 relevant lines covered (57.38%)

12.41 hits per line

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

12.5

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

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 {
  Inject,
  Injectable,
  NotFoundException,
  UnprocessableEntityException,
} from '@nestjs/common';
import { IDataDecodedRepository } from '@/domain/data-decoder/data-decoded.repository.interface';
import { SwapOrderHelper } from '@/routes/transactions/helpers/swap-order.helper';
import { GPv2Decoder } from '@/domain/swaps/contracts/decoders/gp-v2-decoder.helper';
import { DataDecoded } from '@/domain/data-decoder/entities/data-decoded.entity';
import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { TwapOrderHelper } from '@/routes/transactions/helpers/twap-order.helper';
import { OrderStatus } from '@/domain/swaps/entities/order.entity';
import { ISwapsRepository } from '@/domain/swaps/swaps.repository';
import { ComposableCowDecoder } from '@/domain/swaps/contracts/decoders/composable-cow-decoder.helper';
import { SwapAppsHelper } from '@/routes/transactions/helpers/swap-apps.helper';
import { KilnPooledStakingHelper } from '@/routes/transactions/helpers/kiln-pooled-staking.helper';
import { IStakingRepository } from '@/domain/staking/staking.repository.interface';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { NativeStakingMapper } from '@/routes/transactions/mappers/common/native-staking.mapper';
import { PooledStakingMapper } from '@/routes/transactions/mappers/common/pooled-staking.mapper';
import { NativeStakingDepositConfirmationView } from '@/routes/transactions/entities/staking/dedicated-staking-confirmation-view.entity';
import {
  PooledStakingStakeConfirmationView,
  PooledStakingRequestExitConfirmationView,
  PooledStakingWithdrawConfirmationView,
} from '@/routes/transactions/entities/staking/pooled-confirmation-view.entity';
import { DefiStakingMapper } from '@/routes/transactions/mappers/common/defi-staking.mapper';
import {
  DefiStakingDepositConfirmationView,
  DefiStakingWithdrawConfirmationView,
} from '@/routes/transactions/entities/staking/defi-staking-confirmation-view.entity';
import { KilnNativeStakingHelper } from '@/routes/transactions/helpers/kiln-native-staking.helper';
import { KilnDefiStakingHelper } from '@/routes/transactions/helpers/kiln-defi-staking.helper';

@Injectable({})
export class TransactionsViewService {
  private readonly isNativeStakingEnabled: boolean;
  private readonly isPooledStakingEnabled: boolean;
  private readonly isDefiStakingEnabled: 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 defiStakingHelper: KilnDefiStakingHelper,
    private readonly nativeStakingHelper: KilnNativeStakingHelper,
    private readonly pooledStakingHelper: KilnPooledStakingHelper,
    @Inject(IStakingRepository)
    private readonly stakingRepository: IStakingRepository,
    private readonly swapAppsHelper: SwapAppsHelper,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    private readonly nativeStakingMapper: NativeStakingMapper,
    private readonly pooledStakingMapper: PooledStakingMapper,
    private readonly defiStakingMapper: DefiStakingMapper,
  ) {
    this.isNativeStakingEnabled = this.configurationService.getOrThrow<boolean>(
      'features.nativeStaking',
    );
    this.isPooledStakingEnabled = this.configurationService.getOrThrow<boolean>(
      'features.pooledStaking',
    );
    this.isDefiStakingEnabled = this.configurationService.getOrThrow<boolean>(
      'features.defiStaking',
    );
  }

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

    try {
      // Swaps
      const swapOrderData = this.swapOrderHelper.findSwapOrder(
        args.transactionDataDto.data,
      );
      if (swapOrderData) {
        return await this.getSwapOrderConfirmationView({
          chainId: args.chainId,
          data: swapOrderData,
          dataDecoded,
        });
      }

      const twapSwapOrderData = args.transactionDataDto.to
        ? this.twapOrderHelper.findTwapOrder({
            to: args.transactionDataDto.to,
            data: args.transactionDataDto.data,
          })
        : null;
      if (twapSwapOrderData) {
        return await this.getTwapOrderConfirmationView({
          chainId: args.chainId,
          safeAddress: args.safeAddress,
          data: twapSwapOrderData,
          dataDecoded,
        });
      }

      // Dedicated Staking
      const dedicatedStakingDepositData =
        this.isNativeStakingEnabled &&
        (await this.nativeStakingHelper.findDeposit({
          chainId: args.chainId,
          ...args.transactionDataDto,
        }));
      if (dedicatedStakingDepositData) {
        return await this.getNativeStakingDepositConfirmationView({
          chainId: args.chainId,
          to: dedicatedStakingDepositData.to,
          data: dedicatedStakingDepositData.data,
          dataDecoded,
        });
      }

      // Pooled staking
      const pooledStakingStakeData =
        this.isPooledStakingEnabled &&
        (await this.pooledStakingHelper.findStake({
          chainId: args.chainId,
          ...args.transactionDataDto,
        }));
      if (pooledStakingStakeData) {
        return await this.getPooledStakingDepositConfirmationView({
          chainId: args.chainId,
          to: pooledStakingStakeData.to,
          data: pooledStakingStakeData.data,
          dataDecoded,
        });
      }

      const pooledStakingRequestExitData =
        this.isPooledStakingEnabled &&
        (await this.pooledStakingHelper.findRequestExit({
          chainId: args.chainId,
          ...args.transactionDataDto,
        }));
      if (pooledStakingRequestExitData) {
        return await this.getPooledStakingRequestExitConfirmationView({
          chainId: args.chainId,
          to: pooledStakingRequestExitData.to,
          data: pooledStakingRequestExitData.data,
          dataDecoded,
        });
      }

      const pooledStakingWithdrawData =
        this.isPooledStakingEnabled &&
        (await this.pooledStakingHelper.findMultiClaim({
          chainId: args.chainId,
          ...args.transactionDataDto,
        }));
      if (pooledStakingWithdrawData) {
        return await this.getPooledStakingWithdrawConfirmationView({
          chainId: args.chainId,
          to: pooledStakingWithdrawData.to,
          data: pooledStakingWithdrawData.data,
          dataDecoded,
        });
      }

      // DeFi staking
      const defiDepositData =
        this.isDefiStakingEnabled &&
        (await this.defiStakingHelper.findDeposit({
          chainId: args.chainId,
          ...args.transactionDataDto,
        }));
      if (defiDepositData) {
        return await this.getDefiDepositConfirmationView({
          chainId: args.chainId,
          to: defiDepositData.to,
          data: defiDepositData.data,
          dataDecoded,
        });
      }

      const defiWithdrawData =
        this.isDefiStakingEnabled &&
        (await this.defiStakingHelper.findWithdraw({
          chainId: args.chainId,
          ...args.transactionDataDto,
        }));
      if (defiWithdrawData) {
        return await this.getDefiWithdrawConfirmationView({
          chainId: args.chainId,
          to: defiWithdrawData.to,
          data: defiWithdrawData.data,
          dataDecoded,
        });
      }

      throw new UnprocessableEntityException('Unable to decode data');
    } catch (error) {
      this.loggingService.warn(error);
      return new BaselineConfirmationView({
        method: dataDecoded.method,
        parameters: dataDecoded.parameters,
      });
    }
  }

  private async getNativeStakingDepositConfirmationView(args: {
    chainId: string;
    to: `0x${string}`;
    data: `0x${string}`;
    dataDecoded: DataDecoded;
  }): Promise<NativeStakingDepositConfirmationView> {
    const deployment = await this.stakingRepository.getDeployment({
      chainId: args.chainId,
      address: args.to,
    });

    if (deployment.status !== 'active') {
      throw new UnprocessableEntityException(
        'Staking deployment is not active',
      );
    }

    const depositInfo = await this.nativeStakingMapper.mapDepositInfo(args);

    return new NativeStakingDepositConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      ...depositInfo,
    });
  }

  private async getPooledStakingDepositConfirmationView(args: {
    chainId: string;
    to: `0x${string}`;
    data: `0x${string}`;
    dataDecoded: DataDecoded;
  }): Promise<PooledStakingStakeConfirmationView> {
    const deployment = await this.stakingRepository.getDeployment({
      chainId: args.chainId,
      address: args.to,
    });

    if (deployment.status !== 'active') {
      throw new UnprocessableEntityException('Staking pool is not active');
    }

    const stakeInfo = await this.pooledStakingMapper.mapStakeInfo(args);

    return new PooledStakingStakeConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      ...stakeInfo,
    });
  }

  private async getPooledStakingRequestExitConfirmationView(args: {
    chainId: string;
    to: `0x${string}`;
    data: `0x${string}`;
    dataDecoded: DataDecoded;
  }): Promise<PooledStakingRequestExitConfirmationView> {
    const deployment = await this.stakingRepository.getDeployment({
      chainId: args.chainId,
      address: args.to,
    });

    // Don't check if active to support request exist
    if (deployment.status === 'unknown') {
      throw new NotFoundException('Staking pool not found');
    }

    const requestExitInfo =
      await this.pooledStakingMapper.mapRequestExitInfo(args);

    return new PooledStakingRequestExitConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      ...requestExitInfo,
    });
  }

  private async getPooledStakingWithdrawConfirmationView(args: {
    chainId: string;
    to: `0x${string}`;
    data: `0x${string}`;
    dataDecoded: DataDecoded;
  }): Promise<PooledStakingWithdrawConfirmationView> {
    const deployment = await this.stakingRepository.getDeployment({
      chainId: args.chainId,
      address: args.to,
    });

    // Don't check if active to support withdrawal
    if (deployment.status === 'unknown') {
      throw new NotFoundException('Staking pool not found');
    }

    const withdrawInfo = await this.pooledStakingMapper.mapWithdrawInfo(args);

    return new PooledStakingWithdrawConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      ...withdrawInfo,
    });
  }

  private async getDefiDepositConfirmationView(args: {
    chainId: string;
    to: `0x${string}`;
    data: `0x${string}`;
    dataDecoded: DataDecoded;
  }): Promise<DefiStakingDepositConfirmationView> {
    const deployment = await this.stakingRepository.getDeployment({
      chainId: args.chainId,
      address: args.to,
    });

    if (deployment.status !== 'active') {
      throw new UnprocessableEntityException(
        'DeFi staking vault is not active',
      );
    }

    const depositInfo = await this.defiStakingMapper.mapDepositInfo(args);

    return new DefiStakingDepositConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      ...depositInfo,
    });
  }

  private async getDefiWithdrawConfirmationView(args: {
    chainId: string;
    to: `0x${string}`;
    data: `0x${string}`;
    dataDecoded: DataDecoded;
  }): Promise<DefiStakingWithdrawConfirmationView> {
    const deployment = await this.stakingRepository.getDeployment({
      chainId: args.chainId,
      address: args.to,
    });

    // Don't check if active to support withdrawal
    if (deployment.status === 'unknown') {
      throw new NotFoundException('DeFi vault not found');
    }

    const withdrawInfo = await this.defiStakingMapper.mapWithdrawInfo(args);

    return new DefiStakingWithdrawConfirmationView({
      method: args.dataDecoded.method,
      parameters: args.dataDecoded.parameters,
      ...withdrawInfo,
    });
  }

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

1	import { TransactionDataDto } from '@/routes/common/entities/transaction-data.dto.entity';
2	import {	16✔
3	BaselineConfirmationView,
4	ConfirmationView,
5	CowSwapConfirmationView,
6	CowSwapTwapConfirmationView,
7	} from '@/routes/transactions/entities/confirmation-view/confirmation-view.entity';
8	import {	16✔
9	Inject,
10	Injectable,
11	NotFoundException,
12	UnprocessableEntityException,
13	} from '@nestjs/common';
14	import { IDataDecodedRepository } from '@/domain/data-decoder/data-decoded.repository.interface';	16✔
15	import { SwapOrderHelper } from '@/routes/transactions/helpers/swap-order.helper';	16✔
16	import { GPv2Decoder } from '@/domain/swaps/contracts/decoders/gp-v2-decoder.helper';	16✔
17	import { DataDecoded } from '@/domain/data-decoder/entities/data-decoded.entity';
18	import { TokenInfo } from '@/routes/transactions/entities/swaps/token-info.entity';	16✔
19	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	16✔
20	import { TwapOrderHelper } from '@/routes/transactions/helpers/twap-order.helper';	16✔
21	import { OrderStatus } from '@/domain/swaps/entities/order.entity';	16✔
22	import { ISwapsRepository } from '@/domain/swaps/swaps.repository';	16✔
23	import { ComposableCowDecoder } from '@/domain/swaps/contracts/decoders/composable-cow-decoder.helper';	16✔
24	import { SwapAppsHelper } from '@/routes/transactions/helpers/swap-apps.helper';	16✔
25	import { KilnPooledStakingHelper } from '@/routes/transactions/helpers/kiln-pooled-staking.helper';	16✔
26	import { IStakingRepository } from '@/domain/staking/staking.repository.interface';	16✔
27	import { IConfigurationService } from '@/config/configuration.service.interface';	16✔
28	import { NativeStakingMapper } from '@/routes/transactions/mappers/common/native-staking.mapper';	16✔
29	import { PooledStakingMapper } from '@/routes/transactions/mappers/common/pooled-staking.mapper';	16✔
30	import { NativeStakingDepositConfirmationView } from '@/routes/transactions/entities/staking/dedicated-staking-confirmation-view.entity';	16✔
31	import {	16✔
32	PooledStakingStakeConfirmationView,
33	PooledStakingRequestExitConfirmationView,
34	PooledStakingWithdrawConfirmationView,
35	} from '@/routes/transactions/entities/staking/pooled-confirmation-view.entity';
36	import { DefiStakingMapper } from '@/routes/transactions/mappers/common/defi-staking.mapper';	16✔
37	import {	16✔
38	DefiStakingDepositConfirmationView,
39	DefiStakingWithdrawConfirmationView,
40	} from '@/routes/transactions/entities/staking/defi-staking-confirmation-view.entity';
41	import { KilnNativeStakingHelper } from '@/routes/transactions/helpers/kiln-native-staking.helper';	16✔
42	import { KilnDefiStakingHelper } from '@/routes/transactions/helpers/kiln-defi-staking.helper';	16✔
43
44	@Injectable({})
45	export class TransactionsViewService {	16✔
46	private readonly isNativeStakingEnabled: boolean;
47	private readonly isPooledStakingEnabled: boolean;
48	private readonly isDefiStakingEnabled: boolean;
49
50	constructor(
51	@Inject(IDataDecodedRepository)
52	private readonly dataDecodedRepository: IDataDecodedRepository,	×
53	private readonly gpv2Decoder: GPv2Decoder,	×
54	private readonly swapOrderHelper: SwapOrderHelper,	×
55	@Inject(LoggingService) private readonly loggingService: ILoggingService,	×
56	private readonly twapOrderHelper: TwapOrderHelper,	×
57	@Inject(ISwapsRepository)
58	private readonly swapsRepository: ISwapsRepository,	×
59	private readonly composableCowDecoder: ComposableCowDecoder,	×
NEW 60	private readonly defiStakingHelper: KilnDefiStakingHelper,	×
NEW 61	private readonly nativeStakingHelper: KilnNativeStakingHelper,	×
NEW 62	private readonly pooledStakingHelper: KilnPooledStakingHelper,	×
63	@Inject(IStakingRepository)
NEW 64	private readonly stakingRepository: IStakingRepository,	×
UNCOV 65	private readonly swapAppsHelper: SwapAppsHelper,	×
66	@Inject(IConfigurationService)
NEW 67	private readonly configurationService: IConfigurationService,	×
NEW 68	private readonly nativeStakingMapper: NativeStakingMapper,	×
NEW 69	private readonly pooledStakingMapper: PooledStakingMapper,	×
NEW 70	private readonly defiStakingMapper: DefiStakingMapper,	×
71	) {
NEW 72	this.isNativeStakingEnabled = this.configurationService.getOrThrow<boolean>(	×
73	'features.nativeStaking',
74	);
NEW 75	this.isPooledStakingEnabled = this.configurationService.getOrThrow<boolean>(	×
76	'features.pooledStaking',
77	);
NEW 78	this.isDefiStakingEnabled = this.configurationService.getOrThrow<boolean>(	×
79	'features.defiStaking',
80	);
81	}
82
83	async getTransactionConfirmationView(args: {
84	chainId: string;
85	safeAddress: `0x${string}`;
86	transactionDataDto: TransactionDataDto;
87	}): Promise<ConfirmationView> {
NEW 88	const dataDecoded = await this.dataDecodedRepository	×
89	.getDataDecoded({
90	chainId: args.chainId,
91	data: args.transactionDataDto.data,
92	to: args.transactionDataDto.to,
93	})
94	.catch(() => {
95	// TODO: Get Kiln to verify all deployments
96	// Fallback for unverified contracts
NEW 97	return {	×
98	method: '',
99	parameters: null,
100	};
101	});
102
UNCOV 103	try {	×
104	// Swaps
NEW 105	const swapOrderData = this.swapOrderHelper.findSwapOrder(	×
106	args.transactionDataDto.data,
107	);
108	if (swapOrderData) {	×
109	return await this.getSwapOrderConfirmationView({	×
110	chainId: args.chainId,
111	data: swapOrderData,
112	dataDecoded,
113	});
114	}
115
NEW 116	const twapSwapOrderData = args.transactionDataDto.to	×
117	? this.twapOrderHelper.findTwapOrder({
118	to: args.transactionDataDto.to,
119	data: args.transactionDataDto.data,
120	})
121	: null;
NEW 122	if (twapSwapOrderData) {	×
UNCOV 123	return await this.getTwapOrderConfirmationView({	×
124	chainId: args.chainId,
125	safeAddress: args.safeAddress,
126	data: twapSwapOrderData,
127	dataDecoded,
128	});
129	}
130
131	// Dedicated Staking
132	const dedicatedStakingDepositData =
NEW 133	this.isNativeStakingEnabled &&	×
134	(await this.nativeStakingHelper.findDeposit({
135	chainId: args.chainId,
136	...args.transactionDataDto,
137	}));
NEW 138	if (dedicatedStakingDepositData) {	×
NEW 139	return await this.getNativeStakingDepositConfirmationView({	×
140	chainId: args.chainId,
141	to: dedicatedStakingDepositData.to,
142	data: dedicatedStakingDepositData.data,
143	dataDecoded,
144	});
145	}
146
147	// Pooled staking
148	const pooledStakingStakeData =
NEW 149	this.isPooledStakingEnabled &&	×
150	(await this.pooledStakingHelper.findStake({
151	chainId: args.chainId,
152	...args.transactionDataDto,
153	}));
NEW 154	if (pooledStakingStakeData) {	×
NEW 155	return await this.getPooledStakingDepositConfirmationView({	×
156	chainId: args.chainId,
157	to: pooledStakingStakeData.to,
158	data: pooledStakingStakeData.data,
159	dataDecoded,
160	});
161	}
162
163	const pooledStakingRequestExitData =
NEW 164	this.isPooledStakingEnabled &&	×
165	(await this.pooledStakingHelper.findRequestExit({
166	chainId: args.chainId,
167	...args.transactionDataDto,
168	}));
NEW 169	if (pooledStakingRequestExitData) {	×
NEW 170	return await this.getPooledStakingRequestExitConfirmationView({	×
171	chainId: args.chainId,
172	to: pooledStakingRequestExitData.to,
173	data: pooledStakingRequestExitData.data,
174	dataDecoded,
175	});
176	}
177
178	const pooledStakingWithdrawData =
NEW 179	this.isPooledStakingEnabled &&	×
180	(await this.pooledStakingHelper.findMultiClaim({
181	chainId: args.chainId,
182	...args.transactionDataDto,
183	}));
NEW 184	if (pooledStakingWithdrawData) {	×
NEW 185	return await this.getPooledStakingWithdrawConfirmationView({	×
186	chainId: args.chainId,
187	to: pooledStakingWithdrawData.to,
188	data: pooledStakingWithdrawData.data,
189	dataDecoded,
190	});
191	}
192
193	// DeFi staking
194	const defiDepositData =
NEW 195	this.isDefiStakingEnabled &&	×
196	(await this.defiStakingHelper.findDeposit({
197	chainId: args.chainId,
198	...args.transactionDataDto,
199	}));
NEW 200	if (defiDepositData) {	×
NEW 201	return await this.getDefiDepositConfirmationView({	×
202	chainId: args.chainId,
203	to: defiDepositData.to,
204	data: defiDepositData.data,
205	dataDecoded,
206	});
207	}
208
209	const defiWithdrawData =
NEW 210	this.isDefiStakingEnabled &&	×
211	(await this.defiStakingHelper.findWithdraw({
212	chainId: args.chainId,
213	...args.transactionDataDto,
214	}));
NEW 215	if (defiWithdrawData) {	×
NEW 216	return await this.getDefiWithdrawConfirmationView({	×
217	chainId: args.chainId,
218	to: defiWithdrawData.to,
219	data: defiWithdrawData.data,
220	dataDecoded,
221	});
222	}
223
NEW 224	throw new UnprocessableEntityException('Unable to decode data');	×
225	} catch (error) {
226	this.loggingService.warn(error);	×
227	return new BaselineConfirmationView({	×
228	method: dataDecoded.method,
229	parameters: dataDecoded.parameters,
230	});
231	}
232	}
233
234	private async getNativeStakingDepositConfirmationView(args: {
235	chainId: string;
236	to: `0x${string}`;
237	data: `0x${string}`;
238	dataDecoded: DataDecoded;
239	}): Promise<NativeStakingDepositConfirmationView> {
NEW 240	const deployment = await this.stakingRepository.getDeployment({	×
241	chainId: args.chainId,
242	address: args.to,
243	});
244
NEW 245	if (deployment.status !== 'active') {	×
NEW 246	throw new UnprocessableEntityException(	×
247	'Staking deployment is not active',
248	);
249	}
250
NEW 251	const depositInfo = await this.nativeStakingMapper.mapDepositInfo(args);	×
252
NEW 253	return new NativeStakingDepositConfirmationView({	×
254	method: args.dataDecoded.method,
255	parameters: args.dataDecoded.parameters,
256	...depositInfo,
257	});
258	}
259
260	private async getPooledStakingDepositConfirmationView(args: {
261	chainId: string;
262	to: `0x${string}`;
263	data: `0x${string}`;
264	dataDecoded: DataDecoded;
265	}): Promise<PooledStakingStakeConfirmationView> {
NEW 266	const deployment = await this.stakingRepository.getDeployment({	×
267	chainId: args.chainId,
268	address: args.to,
269	});
270
NEW 271	if (deployment.status !== 'active') {	×
NEW 272	throw new UnprocessableEntityException('Staking pool is not active');	×
273	}
274
NEW 275	const stakeInfo = await this.pooledStakingMapper.mapStakeInfo(args);	×
276
NEW 277	return new PooledStakingStakeConfirmationView({	×
278	method: args.dataDecoded.method,
279	parameters: args.dataDecoded.parameters,
280	...stakeInfo,
281	});
282	}
283
284	private async getPooledStakingRequestExitConfirmationView(args: {
285	chainId: string;
286	to: `0x${string}`;
287	data: `0x${string}`;
288	dataDecoded: DataDecoded;
289	}): Promise<PooledStakingRequestExitConfirmationView> {
NEW 290	const deployment = await this.stakingRepository.getDeployment({	×
291	chainId: args.chainId,
292	address: args.to,
293	});
294
295	// Don't check if active to support request exist
NEW 296	if (deployment.status === 'unknown') {	×
NEW 297	throw new NotFoundException('Staking pool not found');	×
298	}
299
300	const requestExitInfo =
NEW 301	await this.pooledStakingMapper.mapRequestExitInfo(args);	×
302
NEW 303	return new PooledStakingRequestExitConfirmationView({	×
304	method: args.dataDecoded.method,
305	parameters: args.dataDecoded.parameters,
306	...requestExitInfo,
307	});
308	}
309
310	private async getPooledStakingWithdrawConfirmationView(args: {
311	chainId: string;
312	to: `0x${string}`;
313	data: `0x${string}`;
314	dataDecoded: DataDecoded;
315	}): Promise<PooledStakingWithdrawConfirmationView> {
NEW 316	const deployment = await this.stakingRepository.getDeployment({	×
317	chainId: args.chainId,
318	address: args.to,
319	});
320
321	// Don't check if active to support withdrawal
NEW 322	if (deployment.status === 'unknown') {	×
NEW 323	throw new NotFoundException('Staking pool not found');	×
324	}
325
NEW 326	const withdrawInfo = await this.pooledStakingMapper.mapWithdrawInfo(args);	×
327
NEW 328	return new PooledStakingWithdrawConfirmationView({	×
329	method: args.dataDecoded.method,
330	parameters: args.dataDecoded.parameters,
331	...withdrawInfo,
332	});
333	}
334
335	private async getDefiDepositConfirmationView(args: {
336	chainId: string;
337	to: `0x${string}`;
338	data: `0x${string}`;
339	dataDecoded: DataDecoded;
340	}): Promise<DefiStakingDepositConfirmationView> {
NEW 341	const deployment = await this.stakingRepository.getDeployment({	×
342	chainId: args.chainId,
343	address: args.to,
344	});
345
NEW 346	if (deployment.status !== 'active') {	×
NEW 347	throw new UnprocessableEntityException(	×
348	'DeFi staking vault is not active',
349	);
350	}
351
NEW 352	const depositInfo = await this.defiStakingMapper.mapDepositInfo(args);	×
353
NEW 354	return new DefiStakingDepositConfirmationView({	×
355	method: args.dataDecoded.method,
356	parameters: args.dataDecoded.parameters,
357	...depositInfo,
358	});
359	}
360
361	private async getDefiWithdrawConfirmationView(args: {
362	chainId: string;
363	to: `0x${string}`;
364	data: `0x${string}`;
365	dataDecoded: DataDecoded;
366	}): Promise<DefiStakingWithdrawConfirmationView> {
NEW 367	const deployment = await this.stakingRepository.getDeployment({	×
368	chainId: args.chainId,
369	address: args.to,
370	});
371
372	// Don't check if active to support withdrawal
NEW 373	if (deployment.status === 'unknown') {	×
NEW 374	throw new NotFoundException('DeFi vault not found');	×
375	}
376
NEW 377	const withdrawInfo = await this.defiStakingMapper.mapWithdrawInfo(args);	×
378
NEW 379	return new DefiStakingWithdrawConfirmationView({	×
380	method: args.dataDecoded.method,
381	parameters: args.dataDecoded.parameters,
382	...withdrawInfo,
383	});
384	}
385
386	private async getSwapOrderConfirmationView(args: {
387	chainId: string;
388	data: `0x${string}`;
389	dataDecoded: DataDecoded;
390	}): Promise<CowSwapConfirmationView> {
391	const orderUid: `0x${string}` \| null =
392	this.gpv2Decoder.getOrderUidFromSetPreSignature(args.data);	×
393	if (!orderUid) {	×
394	throw new Error('Order UID not found in transaction data');	×
395	}
396
397	const order = await this.swapOrderHelper.getOrder({	×
398	chainId: args.chainId,
399	orderUid,
400	});
401
402	if (!this.swapAppsHelper.isAppAllowed(order)) {	×
403	throw new Error(`Unsupported App: ${order.fullAppData?.appCode}`);	×
404	}
405
406	const [sellToken, buyToken] = await Promise.all([	×
407	this.swapOrderHelper.getToken({
408	chainId: args.chainId,
409	address: order.sellToken,
410	}),
411	this.swapOrderHelper.getToken({
412	chainId: args.chainId,
413	address: order.buyToken,
414	}),
415	]);
416
417	return new CowSwapConfirmationView({	×
418	method: args.dataDecoded.method,
419	parameters: args.dataDecoded.parameters,
420	uid: order.uid,
421	status: order.status,
422	kind: order.kind,
423	orderClass: order.class,
424	validUntil: order.validTo,
425	sellAmount: order.sellAmount.toString(),
426	buyAmount: order.buyAmount.toString(),
427	executedSellAmount: order.executedSellAmount.toString(),
428	executedBuyAmount: order.executedBuyAmount.toString(),
429	explorerUrl: this.swapOrderHelper.getOrderExplorerUrl(order).toString(),
430	sellToken: new TokenInfo({
431	address: sellToken.address,
432	decimals: sellToken.decimals,
433	logoUri: sellToken.logoUri,
434	name: sellToken.name,
435	symbol: sellToken.symbol,
436	trusted: sellToken.trusted,
437	}),
438	buyToken: new TokenInfo({
439	address: buyToken.address,
440	decimals: buyToken.decimals,
441	logoUri: buyToken.logoUri,
442	name: buyToken.name,
443	symbol: buyToken.symbol,
444	trusted: buyToken.trusted,
445	}),
446	executedSurplusFee: order.executedSurplusFee?.toString() ?? null,	×
447	receiver: order.receiver,
448	owner: order.owner,
449	fullAppData: order.fullAppData,
450	});
451	}
452
453	private async getTwapOrderConfirmationView(args: {
454	chainId: string;
455	safeAddress: `0x${string}`;
456	data: `0x${string}`;
457	dataDecoded: DataDecoded;
458	}): Promise<CowSwapTwapConfirmationView> {
459	// Decode `staticInput` of `createWithContextCall`
460	const twapStruct = this.composableCowDecoder.decodeTwapStruct(args.data);	×
461	const twapOrderData =
462	this.twapOrderHelper.twapStructToPartialOrderInfo(twapStruct);	×
463
464	// Generate parts of the TWAP order
465	const twapParts = this.twapOrderHelper.generateTwapOrderParts({	×
466	twapStruct,
467	executionDate: new Date(),
468	chainId: args.chainId,
469	});
470
471	// Decode hash of `appData`
472	const fullAppData = await this.swapsRepository.getFullAppData(	×
473	args.chainId,
474	twapStruct.appData,
475	);
476
477	if (!this.swapAppsHelper.isAppAllowed(fullAppData)) {	×
478	throw new Error(`Unsupported App: ${fullAppData.fullAppData?.appCode}`);	×
479	}
480
481	const [buyToken, sellToken] = await Promise.all([	×
482	this.swapOrderHelper.getToken({
483	chainId: args.chainId,
484	address: twapStruct.buyToken,
485	}),
486	this.swapOrderHelper.getToken({
487	chainId: args.chainId,
488	address: twapStruct.sellToken,
489	}),
490	]);
491
492	return new CowSwapTwapConfirmationView({	×
493	method: args.dataDecoded.method,
494	parameters: args.dataDecoded.parameters,
495	status: OrderStatus.PreSignaturePending,
496	kind: twapOrderData.kind,
497	class: twapOrderData.class,
498	activeOrderUid: null,
499	validUntil: Math.max(...twapParts.map((order) => order.validTo)),	×
500	sellAmount: twapOrderData.sellAmount,
501	buyAmount: twapOrderData.buyAmount,
502	executedSellAmount: '0',
503	executedBuyAmount: '0',
504	executedSurplusFee: '0',
505	sellToken: new TokenInfo({
506	address: sellToken.address,
507	decimals: sellToken.decimals,
508	logoUri: sellToken.logoUri,
509	name: sellToken.name,
510	symbol: sellToken.symbol,
511	trusted: sellToken.trusted,
512	}),
513	buyToken: new TokenInfo({
514	address: buyToken.address,
515	decimals: buyToken.decimals,
516	logoUri: buyToken.logoUri,
517	name: buyToken.name,
518	symbol: buyToken.symbol,
519	trusted: buyToken.trusted,
520	}),
521	receiver: twapStruct.receiver,
522	owner: args.safeAddress,
523	fullAppData: fullAppData.fullAppData,
524	numberOfParts: twapOrderData.numberOfParts,
525	partSellAmount: twapStruct.partSellAmount.toString(),
526	minPartLimit: twapStruct.minPartLimit.toString(),
527	timeBetweenParts: twapOrderData.timeBetweenParts,
528	durationOfPart: twapOrderData.durationOfPart,
529	startTime: twapOrderData.startTime,
530	});
531	}
532	}

safe-global / safe-client-gateway / 10456336577

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