@subwallet/extension-base 1.3.21-0 → 1.3.23-0

package/services/swap-service/handler/simpleswap-handler.js

@@ -4,15 +4,14 @@
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { _getSimpleSwapEarlyValidationError } from '@subwallet/extension-base/core/logic-validation/swap';
-import { _getAssetDecimals, _getChainNativeTokenSlug, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
-import { BasicTxErrorType, CommonStepType, SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
+import { _getAssetDecimals, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { BasicTxErrorType, CommonStepType, SwapErrorType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
 import { _reformatAddressWithChain, formatNumber } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigN, { BigNumber } from 'bignumber.js';
 import { getERC20TransactionObject, getEVMTransactionObject } from "../../balance-service/transfer/smart-contract.js";
-import { createTransferExtrinsic, getTransferMockTxFee } from "../../balance-service/transfer/token.js";
-import { calculateSwapRate, SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING, SWAP_QUOTE_TIMEOUT_MAP } from "../utils.js";
+import { createSubstrateExtrinsic } from "../../balance-service/transfer/token.js";
+import { SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING } from "../utils.js";
 import { SwapBaseHandler } from "./base-handler.js";
 const apiUrl = 'https://api.simpleswap.io';
 export const simpleSwapApiKey = process.env.SIMPLE_SWAP_API_KEY || '';
@@ -20,72 +19,6 @@ const toBNString = (input, decimal) => {
   const raw = new BigNumber(input);
   return raw.shiftedBy(decimal).integerValue(BigNumber.ROUND_CEIL).toFixed();
 };
-const fetchSwapList = async params => {
-  const swapListParams = new URLSearchParams({
-    api_key: `${simpleSwapApiKey}`,
-    fixed: 'false',
-    symbol: params.fromSymbol
-  });
-  const response = await fetch(`${apiUrl}/get_pairs?${swapListParams.toString()}`, {
-    headers: {
-      accept: 'application/json'
-    }
-  });
-  return await response.json();
-};
-const fetchRanges = async params => {
-  const rangesParams = new URLSearchParams({
-    api_key: `${simpleSwapApiKey}`,
-    fixed: 'false',
-    currency_from: params.fromSymbol,
-    currency_to: params.toSymbol
-  });
-  const response = await fetch(`${apiUrl}/get_ranges?${rangesParams.toString()}`, {
-    headers: {
-      accept: 'application/json'
-    }
-  });
-  return await response.json();
-};
-async function getEstimate(request, fromAsset, toAsset) {
-  const fromSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[fromAsset.slug];
-  const toSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[toAsset.slug];
-  const assetDecimals = _getAssetDecimals(fromAsset);
-  if (!fromSymbol || !toSymbol) {
-    throw new SwapError(SwapErrorType.ASSET_NOT_SUPPORTED);
-  }
-  const formatedAmount = formatNumber(request.fromAmount, assetDecimals, s => s);
-  const params = new URLSearchParams({
-    api_key: `${simpleSwapApiKey}`,
-    fixed: 'false',
-    currency_from: fromSymbol,
-    currency_to: toSymbol,
-    amount: formatedAmount
-  });
-  try {
-    const response = await fetch(`${apiUrl}/get_estimated?${params.toString()}`, {
-      headers: {
-        accept: 'application/json'
-      }
-    });
-    if (!response.ok) {
-      throw new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
-    }
-    const resToAmount = await response.json();
-    const toAmount = toBNString(resToAmount, _getAssetDecimals(toAsset));
-    const bnToAmount = new BigN(toAmount);
-    const walletFeeRate = 4 / 1000;
-    const toAmountBeforeFee = bnToAmount.dividedBy(new BigN(1 - walletFeeRate));
-    const walletFeeAmount = toAmountBeforeFee.multipliedBy(4).dividedBy(1000).toString();
-    return {
-      toAmount,
-      walletFeeAmount
-    };
-  } catch (err) {
-    console.error('Error:', err);
-    throw new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
-  }
-}
 const createSwapRequest = async params => {
   const fromDecimals = _getAssetDecimals(params.fromAsset);
   const toDecimals = _getAssetDecimals(params.toAsset);
@@ -169,70 +102,6 @@ export class SimpleSwapHandler {
   get slug() {
     return this.swapBaseHandler.slug;
   }
-  async getSwapQuote(request) {
-    try {
-      var _metadata$maxSwap;
-      const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
-      const toAsset = this.chainService.getAssetBySlug(request.pair.to);
-      if (!fromAsset || !toAsset) {
-        return new SwapError(SwapErrorType.UNKNOWN);
-      }
-      const earlyValidation = await this.validateSwapRequest(request);
-      const metadata = earlyValidation.metadata;
-      if (earlyValidation.error) {
-        return _getSimpleSwapEarlyValidationError(earlyValidation.error, metadata);
-      }
-      const {
-        toAmount,
-        walletFeeAmount
-      } = await getEstimate(request, fromAsset, toAsset);
-      const fromAmount = request.fromAmount;
-      const rate = calculateSwapRate(request.fromAmount, toAmount, fromAsset, toAsset);
-      const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
-      const fromChainNativeTokenSlug = _getChainNativeTokenSlug(fromChain);
-      const defaultFeeToken = _isNativeToken(fromAsset) ? fromAsset.slug : fromChainNativeTokenSlug;
-      const chainType = _isChainSubstrateCompatible(fromChain) ? ChainType.SUBSTRATE : ChainType.EVM;
-      let api;
-      if (chainType === ChainType.SUBSTRATE) {
-        api = this.chainService.getSubstrateApi(fromChain.slug);
-      } else {
-        api = this.chainService.getEvmApi(fromChain.slug);
-      }
-      const networkFeeAmount = await getTransferMockTxFee(request.address, fromChain, fromAsset, api);
-      const networkFee = {
-        tokenSlug: fromChainNativeTokenSlug,
-        amount: networkFeeAmount.toString(),
-        feeType: SwapFeeType.NETWORK_FEE
-      };
-      const walletFee = {
-        tokenSlug: toAsset.slug,
-        amount: walletFeeAmount,
-        feeType: SwapFeeType.WALLET_FEE
-      };
-      return {
-        pair: request.pair,
-        fromAmount,
-        toAmount,
-        rate,
-        provider: this.providerInfo,
-        aliveUntil: +Date.now() + (SWAP_QUOTE_TIMEOUT_MAP[this.slug] || SWAP_QUOTE_TIMEOUT_MAP.default),
-        minSwap: toBNString(metadata.minSwap.value, _getAssetDecimals(fromAsset)),
-        maxSwap: toBNString((_metadata$maxSwap = metadata.maxSwap) === null || _metadata$maxSwap === void 0 ? void 0 : _metadata$maxSwap.value, _getAssetDecimals(fromAsset)),
-        estimatedArrivalTime: 3600,
-        isLowLiquidity: false,
-        feeInfo: {
-          feeComponent: [networkFee, walletFee],
-          defaultFeeToken,
-          feeOptions: [defaultFeeToken]
-        },
-        route: {
-          path: [fromAsset.slug, toAsset.slug]
-        }
-      };
-    } catch (e) {
-      return new SwapError(SwapErrorType.UNKNOWN);
-    }
-  }
   generateOptimalProcess(params) {
     return this.swapBaseHandler.generateOptimalProcess(params, [this.getSubmitStep.bind(this)]);
   }
@@ -246,96 +115,6 @@ export class SimpleSwapHandler {
     }
     return Promise.resolve(undefined);
   }
-  async validateSwapRequest(request) {
-    try {
-      const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
-      const toAsset = this.chainService.getAssetBySlug(request.pair.to);
-      if (!fromAsset || !toAsset) {
-        return {
-          error: SwapErrorType.ERROR_FETCHING_QUOTE
-        };
-      }
-      const fromSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[fromAsset.slug];
-      const toSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[toAsset.slug];
-      if (!fromSymbol || !toSymbol) {
-        return {
-          error: SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      try {
-        const swapList = await fetchSwapList({
-          fromSymbol
-        });
-        if (!swapList.includes(toSymbol)) {
-          return {
-            error: SwapErrorType.ASSET_NOT_SUPPORTED
-          };
-        }
-      } catch (err) {
-        console.error('Error:', err);
-      }
-      const ranges = await fetchRanges({
-        fromSymbol,
-        toSymbol
-      });
-      const {
-        max,
-        min
-      } = ranges;
-      const bnMin = toBNString(min, _getAssetDecimals(fromAsset));
-      const bnAmount = BigInt(request.fromAmount);
-      if (bnAmount < BigInt(bnMin)) {
-        return {
-          error: SwapErrorType.NOT_MEET_MIN_SWAP,
-          metadata: {
-            minSwap: {
-              value: min,
-              symbol: fromAsset.symbol
-            },
-            maxSwap: max ? {
-              value: max,
-              symbol: fromAsset.symbol
-            } : undefined,
-            chain: this.chainService.getChainInfoByKey(fromAsset.originChain)
-          }
-        };
-      }
-      if (max && bnAmount > BigInt(toBNString(max, _getAssetDecimals(fromAsset)))) {
-        return {
-          error: SwapErrorType.SWAP_EXCEED_ALLOWANCE,
-          metadata: {
-            minSwap: {
-              value: min,
-              symbol: fromAsset.symbol
-            },
-            maxSwap: {
-              value: max,
-              symbol: fromAsset.symbol
-            },
-            chain: this.chainService.getChainInfoByKey(fromAsset.originChain)
-          }
-        };
-      }
-      return {
-        metadata: {
-          minSwap: {
-            value: min,
-            symbol: fromAsset.symbol
-          },
-          maxSwap: max ? {
-            value: max,
-            symbol: fromAsset.symbol
-          } : undefined,
-          chain: this.chainService.getChainInfoByKey(fromAsset.originChain)
-        }
-      };
-    } catch (e) {
-      console.error(e);
-      return {
-        error: SwapErrorType.UNKNOWN
-      };
-    }
-  }
   async handleSwapProcess(params) {
     const {
       currentStep,
@@ -405,7 +184,7 @@ export class SimpleSwapHandler {
     if (chainType === ChainType.SUBSTRATE) {
       const chainApi = this.chainService.getSubstrateApi(chainInfo.slug);
       const substrateApi = await chainApi.isReady;
-      const [submittableExtrinsic] = await createTransferExtrinsic({
+      const [submittableExtrinsic] = await createSubstrateExtrinsic({
         from: address,
         networkKey: chainInfo.slug,
         substrateApi,

package/services/swap-service/handler/uniswap-handler.d.ts

@@ -0,0 +1,41 @@
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import TransactionService from '@subwallet/extension-base/services/transaction-service';
+import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo, OptimalSwapPathParams, PermitSwapData, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { TransactionConfig } from 'web3-core';
+import { BalanceService } from '../../balance-service';
+import { ChainService } from '../../chain-service';
+import FeeService from '../../fee-service/service';
+import { SwapBaseInterface } from './base-handler';
+export declare type PermitData = {
+    domain: Record<string, unknown>;
+    types: Record<string, unknown>;
+    values: unknown;
+};
+export declare class UniswapHandler implements SwapBaseInterface {
+    private swapBaseHandler;
+    transactionService: TransactionService;
+    providerSlug: SwapProviderId;
+    constructor(chainService: ChainService, balanceService: BalanceService, transactionService: TransactionService, feeService: FeeService);
+    get chainService(): ChainService;
+    get balanceService(): BalanceService;
+    get feeService(): FeeService;
+    get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalPath>;
+    getApprovalStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getPermitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    private tokenApproveSpending;
+    handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handlePermitStep(params: SwapSubmitParams): {
+        txChain: string;
+        txData: PermitSwapData;
+        extrinsic: TransactionConfig;
+        extrinsicType: ExtrinsicType;
+        transferNativeAmount: string;
+        chainType: ChainType;
+        isPermit: boolean;
+    };
+}

package/services/swap-service/handler/uniswap-handler.js

@@ -0,0 +1,323 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { validateTypedSignMessageDataV3V4 } from '@subwallet/extension-base/core/logic-validation';
+import { BasicTxErrorType, CommonStepType, FeeOptionKey, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types';
+import BigNumber from 'bignumber.js';
+import { _getContractAddressOfToken, _isNativeToken } from "../../chain-service/utils/index.js";
+import { calculateGasFeeParams } from "../../fee-service/utils/index.js";
+import { SwapBaseHandler } from "./base-handler.js";
+const API_URL = 'https://trade-api.gateway.uniswap.org/v1';
+const headers = {
+  'x-api-key': process.env.UNISWAP_API_KEY || ''
+};
+async function fetchCheckApproval(walletAddress, fromAmount, quote) {
+  const chainId = quote.chainId;
+  const response = await fetch(`${API_URL}/check_approval`, {
+    method: 'POST',
+    headers: {
+      ...headers,
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify({
+      walletAddress,
+      amount: BigNumber(fromAmount).multipliedBy(2).toString(),
+      token: quote.input.token,
+      chainId: chainId,
+      tokenOut: quote.output.token,
+      tokenOutChainId: chainId
+    })
+  });
+  const data = await response.json();
+  return data;
+}
+export class UniswapHandler {
+  constructor(chainService, balanceService, transactionService, feeService) {
+    this.swapBaseHandler = new SwapBaseHandler({
+      chainService,
+      balanceService,
+      feeService,
+      providerName: 'Uniswap',
+      providerSlug: SwapProviderId.UNISWAP
+    });
+    this.transactionService = transactionService;
+    this.providerSlug = SwapProviderId.UNISWAP;
+  }
+  get chainService() {
+    return this.swapBaseHandler.chainService;
+  }
+  get balanceService() {
+    return this.swapBaseHandler.balanceService;
+  }
+  get feeService() {
+    return this.swapBaseHandler.feeService;
+  }
+  get providerInfo() {
+    return this.swapBaseHandler.providerInfo;
+  }
+  generateOptimalProcess(params) {
+    return this.swapBaseHandler.generateOptimalProcess(params, [this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
+  }
+  async getApprovalStep(params) {
+    if (params.selectedQuote) {
+      const walletAddress = params.request.address;
+      const fromAmount = params.selectedQuote.fromAmount;
+      const inputTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+      const {
+        quote
+      } = params.selectedQuote.metadata;
+      const checkApprovalResponse = await fetchCheckApproval(walletAddress, fromAmount, quote);
+      const approval = checkApprovalResponse.approval;
+      if (approval) {
+        let spender = '';
+        try {
+          const valueLength = 40;
+          spender = approval.data.slice(-(valueLength * 2), -valueLength);
+        } catch (e) {
+          // Empty
+        }
+        const metadata = {
+          tokenApprove: inputTokenInfo.slug,
+          contractAddress: _getContractAddressOfToken(inputTokenInfo),
+          spenderAddress: spender
+        };
+        const submitStep = {
+          name: 'Approve token',
+          type: CommonStepType.TOKEN_APPROVAL,
+          metadata: metadata
+        };
+        return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+      }
+    }
+    return Promise.resolve(undefined);
+  }
+  async getPermitStep(params) {
+    if (params.selectedQuote && params.selectedQuote.metadata.permitData) {
+      const submitStep = {
+        name: 'Permit Step',
+        type: SwapStepType.PERMIT
+      };
+      // TODO: GET NATIVE TOKEN
+      const defaultFeeToken = params.selectedQuote.feeInfo.defaultFeeToken;
+      const feeInfo = {
+        feeComponent: [{
+          amount: '0',
+          feeType: SwapFeeType.NETWORK_FEE,
+          tokenSlug: defaultFeeToken
+        }],
+        defaultFeeToken: defaultFeeToken,
+        feeOptions: [defaultFeeToken]
+      };
+      return Promise.resolve([submitStep, feeInfo]);
+    }
+    return Promise.resolve(undefined);
+  }
+  async getSubmitStep(params) {
+    if (params.selectedQuote) {
+      const submitStep = {
+        name: 'Swap',
+        type: SwapStepType.SWAP
+      };
+      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    }
+    return Promise.resolve(undefined);
+  }
+  async validateSwapProcess(params) {
+    const amount = params.selectedQuote.fromAmount;
+    const bnAmount = BigInt(amount);
+    if (bnAmount <= BigInt(0)) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')]);
+    }
+    let isXcmOk = false;
+    for (const [index, step] of params.process.steps.entries()) {
+      const getErrors = async () => {
+        switch (step.type) {
+          case CommonStepType.DEFAULT:
+            return Promise.resolve([]);
+          case CommonStepType.TOKEN_APPROVAL:
+            return Promise.resolve([]);
+          default:
+            return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
+        }
+      };
+      const errors = await getErrors();
+      if (errors.length) {
+        return errors;
+      } else if (step.type === CommonStepType.XCM) {
+        isXcmOk = true;
+      }
+    }
+    return [];
+  }
+  async handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case CommonStepType.DEFAULT:
+        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+      case CommonStepType.TOKEN_APPROVAL:
+        return this.tokenApproveSpending(params);
+      case SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      case SwapStepType.PERMIT:
+        return this.handlePermitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  async tokenApproveSpending(params) {
+    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    const walletAddress = params.address;
+    const fromAmount = params.quote.fromAmount;
+    const {
+      quote
+    } = params.quote.metadata;
+    const checkApprovalResponse = await fetchCheckApproval(walletAddress, fromAmount, quote);
+    let transactionConfig = {};
+    const approval = checkApprovalResponse.approval;
+    if (approval) {
+      var _priority$options, _priority$options$Fee, _priority$options2;
+      const evmApi = this.chainService.getEvmApi(fromAsset.originChain);
+      const priority = await calculateGasFeeParams(evmApi, evmApi.chainSlug);
+      transactionConfig = {
+        from: approval.from,
+        to: approval.to,
+        value: approval.value,
+        data: approval.data,
+        gasPrice: priority.gasPrice,
+        maxFeePerGas: (_priority$options = priority.options) === null || _priority$options === void 0 ? void 0 : (_priority$options$Fee = _priority$options[FeeOptionKey.AVERAGE].maxFeePerGas) === null || _priority$options$Fee === void 0 ? void 0 : _priority$options$Fee.toString(),
+        maxPriorityFeePerGas: (_priority$options2 = priority.options) === null || _priority$options2 === void 0 ? void 0 : _priority$options2[FeeOptionKey.AVERAGE].maxPriorityFeePerGas.toString()
+      };
+      const gasLimit = await evmApi.api.eth.estimateGas(transactionConfig).catch(() => 200000);
+      transactionConfig.gas = gasLimit.toString();
+    }
+    const chain = fromAsset.originChain;
+    const _data = {
+      spenderAddress: quote.output.token,
+      contractAddress: quote.input.token,
+      amount: params.quote.fromAmount,
+      owner: params.address,
+      chain: quote.chainId.toString()
+    };
+    return Promise.resolve({
+      txChain: chain,
+      extrinsicType: ExtrinsicType.TOKEN_SPENDING_APPROVAL,
+      extrinsic: transactionConfig,
+      txData: _data,
+      transferNativeAmount: '0',
+      chainType: ChainType.EVM
+    });
+  }
+  async handleSubmitStep(params) {
+    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    const {
+      permitData,
+      quote,
+      routing
+    } = params.quote.metadata;
+    const processId = params.cacheProcessId;
+    let signature;
+    if (permitData) {
+      signature = this.transactionService.getCacheInfo(processId, SwapStepType.PERMIT);
+    }
+    let postTransactionResponse;
+    let extrinsic;
+    if (routing === 'CLASSIC' || routing === 'WRAP' || routing === 'UNWRAP') {
+      const body = {
+        signature: signature,
+        quote: quote
+      };
+      if (permitData) {
+        body.permitData = permitData;
+      }
+      postTransactionResponse = await fetch(`${API_URL}/swap`, {
+        method: 'POST',
+        headers: {
+          ...headers,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(body)
+      });
+      const transactionResponse = await postTransactionResponse.json();
+      extrinsic = transactionResponse.swap;
+    } else if (routing === 'DUTCH_LIMIT' || routing === 'DUTCH_V2') {
+      postTransactionResponse = await fetch(`${API_URL}/order`, {
+        method: 'POST',
+        headers: {
+          ...headers,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          signature: signature,
+          quote: quote
+        })
+      });
+    }
+    const txData = {
+      address: params.address,
+      provider: this.providerInfo,
+      quote: params.quote,
+      slippage: params.slippage,
+      recipient: params.recipient,
+      process: params.process
+    };
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic: extrinsic,
+      transferNativeAmount: _isNativeToken(fromAsset) ? params.quote.fromAmount : '0',
+      extrinsicType: ExtrinsicType.SWAP,
+      chainType: ChainType.EVM
+    };
+  }
+  handlePermitStep(params) {
+    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    const {
+      permitData
+    } = params.quote.metadata;
+    const processId = params.cacheProcessId;
+    let validatePayload;
+    if (permitData) {
+      const payload = {
+        types: {
+          EIP712Domain: [{
+            name: 'name',
+            type: 'string'
+          }, {
+            name: 'chainId',
+            type: 'uint256'
+          }, {
+            name: 'verifyingContract',
+            type: 'address'
+          }],
+          ...permitData.types
+        },
+        domain: permitData.domain,
+        primaryType: 'PermitSingle',
+        message: permitData.values
+      };
+      validatePayload = validateTypedSignMessageDataV3V4({
+        data: payload,
+        from: params.address
+      });
+    }
+    const txData = {
+      processId,
+      step: SwapStepType.PERMIT
+    };
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic: validatePayload,
+      extrinsicType: ExtrinsicType.TOKEN_SPENDING_APPROVAL,
+      transferNativeAmount: '0',
+      chainType: ChainType.EVM,
+      isPermit: true
+    };
+  }
+}