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

package/cjs/services/swap-service/handler/hydradx-handler.js

@@ -7,25 +7,22 @@ Object.defineProperty(exports, "__esModule", {
 exports.HydradxHandler = void 0;
 var _sdk = require("@galacticcouncil/sdk");
 var _chainList = require("@subwallet/chain-list");
-var _types = require("@subwallet/chain-list/types");
 var _SwapError = require("@subwallet/extension-base/background/errors/SwapError");
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _constants = require("@subwallet/extension-base/constants");
-var _swap = require("@subwallet/extension-base/core/logic-validation/swap");
 var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _baseHandler = require("@subwallet/extension-base/services/swap-service/handler/base-handler");
 var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
-var _types2 = require("@subwallet/extension-base/types");
+var _types = require("@subwallet/extension-base/types");
 var _serviceBase = require("@subwallet/extension-base/types/service-base");
-var _swap2 = require("@subwallet/extension-base/types/swap");
+var _swap = require("@subwallet/extension-base/types/swap");
 var _getId = require("@subwallet/extension-base/utils/getId");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-const HYDRADX_LOW_LIQUIDITY_THRESHOLD = 0.15;
 const HYDRADX_SUBWALLET_REFERRAL_CODE = 'WALLET';
 const HYDRADX_SUBWALLET_REFERRAL_ACCOUNT = '7PCsCpkgsHdNaZhv79wCCQ5z97uxVbSeSCtDMUa1eZHKXy4a';
 const HYDRADX_TESTNET_SUBWALLET_REFERRAL_CODE = 'ASSETHUB';
@@ -40,9 +37,9 @@ class HydradxHandler {
       chainService,
       feeService,
       providerName: isTestnet ? 'Hydration Testnet' : 'Hydration',
-      providerSlug: isTestnet ? _swap2.SwapProviderId.HYDRADX_TESTNET : _swap2.SwapProviderId.HYDRADX_MAINNET
+      providerSlug: isTestnet ? _swap.SwapProviderId.HYDRADX_TESTNET : _swap.SwapProviderId.HYDRADX_MAINNET
     });
-    this.providerSlug = isTestnet ? _swap2.SwapProviderId.HYDRADX_TESTNET : _swap2.SwapProviderId.HYDRADX_MAINNET;
+    this.providerSlug = isTestnet ? _swap.SwapProviderId.HYDRADX_TESTNET : _swap.SwapProviderId.HYDRADX_MAINNET;
     this.isTestnet = isTestnet;
   }
   async init() {
@@ -120,7 +117,7 @@ class HydradxHandler {
       const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
       const fee = {
         feeComponent: [{
-          feeType: _swap2.SwapFeeType.NETWORK_FEE,
+          feeType: _swap.SwapFeeType.NETWORK_FEE,
           amount: Math.round(xcmFeeInfo.partialFee * _constants.XCM_MIN_AMOUNT_RATIO).toString(),
           tokenSlug: (0, _utils._getChainNativeTokenSlug)(alternativeChainInfo)
         }],
@@ -175,7 +172,7 @@ class HydradxHandler {
       const txFee = _txFee.toPrimitive();
       const fee = {
         feeComponent: [{
-          feeType: _swap2.SwapFeeType.NETWORK_FEE,
+          feeType: _swap.SwapFeeType.NETWORK_FEE,
           amount: Math.round(txFee.partialFee).toString(),
           tokenSlug: selectedFeeAsset.slug
         }],
@@ -192,7 +189,7 @@ class HydradxHandler {
     if (params.selectedQuote) {
       const submitStep = {
         name: 'Swap',
-        type: _swap2.SwapStepType.SWAP
+        type: _swap.SwapStepType.SWAP
       };
       return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
     }
@@ -203,120 +200,6 @@ class HydradxHandler {
     // this.getFeeOptionStep.bind(this),
     this.getSubmitStep.bind(this)]);
   }
-  getSwapPathErrors(swapList) {
-    return swapList.reduce((prev, current) => {
-      return [...prev, ...current.errors];
-    }, []);
-  }
-  parseSwapPath(swapList) {
-    const swapAssets = this.chainService.getAssetByChainAndType(this.chain(), [_types._AssetType.NATIVE, _types._AssetType.LOCAL]);
-    const swapAssetIdMap = Object.values(swapAssets).reduce((accumulator, asset) => {
-      return {
-        ...accumulator,
-        [(0, _utils._getTokenOnChainAssetId)(asset)]: asset
-      };
-    }, {});
-    const path = [];
-    swapList.forEach(swap => {
-      var _swapAssetIdMap$swap$, _swapAssetIdMap$swap$2;
-      const swapAssetIn = (_swapAssetIdMap$swap$ = swapAssetIdMap[swap.assetIn]) === null || _swapAssetIdMap$swap$ === void 0 ? void 0 : _swapAssetIdMap$swap$.slug;
-      const swapAssetOut = (_swapAssetIdMap$swap$2 = swapAssetIdMap[swap.assetOut]) === null || _swapAssetIdMap$swap$2 === void 0 ? void 0 : _swapAssetIdMap$swap$2.slug;
-      if (swapAssetIn && !path.includes(swapAssetIn)) {
-        path.push(swapAssetIn);
-      }
-      if (swapAssetOut && !path.includes(swapAssetOut)) {
-        path.push(swapAssetOut);
-      }
-    });
-    return {
-      path
-    };
-  }
-  async getSwapQuote(request) {
-    const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
-    const toAsset = this.chainService.getAssetBySlug(request.pair.to);
-    const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
-    const fromChainNativeTokenSlug = (0, _utils._getChainNativeTokenSlug)(fromChain);
-    if (!this.isReady || !this.tradeRouter) {
-      return new _SwapError.SwapError(_swap2.SwapErrorType.UNKNOWN);
-    }
-    const earlyValidation = await this.validateSwapRequest(request);
-    if (earlyValidation.error) {
-      const metadata = earlyValidation.metadata;
-      return (0, _swap._getEarlyHydradxValidationError)(earlyValidation.error, metadata);
-    }
-    try {
-      const fromAssetId = (0, _utils._getTokenOnChainAssetId)(fromAsset);
-      const toAssetId = (0, _utils._getTokenOnChainAssetId)(toAsset);
-      const parsedFromAmount = new _bignumber.default(request.fromAmount).shiftedBy(-1 * (0, _utils._getAssetDecimals)(fromAsset)).toString();
-      const quoteResponse = await this.tradeRouter.getBestSell(fromAssetId, toAssetId, parsedFromAmount);
-      const toAmount = quoteResponse.amountOut;
-      const minReceive = toAmount.times(1 - request.slippage).integerValue();
-      const txHex = quoteResponse.toTx(minReceive).hex;
-      const substrateApi = this.chainService.getSubstrateApi(this.chain());
-      const extrinsic = substrateApi.api.tx(txHex);
-      const paymentInfo = await extrinsic.paymentInfo(request.address);
-      const networkFee = {
-        tokenSlug: fromChainNativeTokenSlug,
-        amount: paymentInfo.partialFee.toString(),
-        feeType: _swap2.SwapFeeType.NETWORK_FEE
-      };
-      const tradeFee = {
-        tokenSlug: toAsset.slug,
-        // fee is subtracted from receiving amount
-        amount: quoteResponse.tradeFee.toString(),
-        feeType: _swap2.SwapFeeType.PLATFORM_FEE
-      };
-      const swapRoute = this.parseSwapPath(quoteResponse.swaps);
-      const swapPathErrors = this.getSwapPathErrors(quoteResponse.swaps);
-      if (swapPathErrors.length > 0) {
-        const defaultError = swapPathErrors[0]; // might parse more errors
-
-        switch (defaultError) {
-          case _sdk.PoolError.InsufficientTradingAmount:
-            return new _SwapError.SwapError(_swap2.SwapErrorType.NOT_MEET_MIN_SWAP);
-          case _sdk.PoolError.TradeNotAllowed:
-            return new _SwapError.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
-          case _sdk.PoolError.MaxInRatioExceeded:
-            return new _SwapError.SwapError(_swap2.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
-          case _sdk.PoolError.UnknownError:
-            return new _SwapError.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
-          case _sdk.PoolError.MaxOutRatioExceeded:
-            return new _SwapError.SwapError(_swap2.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
-        }
-      }
-
-      // const feeTokenOptions = this.chainService.getFeeTokensByChain(this.chain());
-      const feeTokenOptions = [fromChainNativeTokenSlug];
-
-      // if (request.feeToken && !feeTokenOptions.includes(request.feeToken)) {
-      //   return new SwapError(SwapErrorType.UNKNOWN);
-      // }
-
-      // const selectedFeeToken = request.feeToken || fromChainNativeTokenSlug;
-      const selectedFeeToken = fromChainNativeTokenSlug;
-      return {
-        pair: request.pair,
-        fromAmount: request.fromAmount,
-        toAmount: toAmount.toString(),
-        rate: (0, _utils2.calculateSwapRate)(request.fromAmount, toAmount.toString(), fromAsset, toAsset),
-        provider: this.providerInfo,
-        aliveUntil: +Date.now() + (_utils2.SWAP_QUOTE_TIMEOUT_MAP[this.slug] || _utils2.SWAP_QUOTE_TIMEOUT_MAP.default),
-        feeInfo: {
-          feeComponent: [networkFee, tradeFee],
-          defaultFeeToken: fromChainNativeTokenSlug,
-          feeOptions: feeTokenOptions,
-          // TODO: enable fee options
-          selectedFeeToken
-        },
-        isLowLiquidity: Math.abs(quoteResponse.priceImpactPct) >= HYDRADX_LOW_LIQUIDITY_THRESHOLD,
-        route: swapRoute,
-        metadata: txHex
-      };
-    } catch (e) {
-      return new _SwapError.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
-    }
-  }
   async handleXcmStep(params) {
     const pair = params.quote.pair;
     const alternativeAssetSlug = (0, _utils2.getSwapAlternativeAsset)(pair);
@@ -370,9 +253,9 @@ class HydradxHandler {
     var _swapFeeInfo$selected;
     const substrateApi = this.chainService.getSubstrateApi(this.chain());
     const chainApi = await substrateApi.isReady;
-    const swapStepIndex = params.process.steps.findIndex(step => step.type === _swap2.SwapStepType.SWAP);
+    const swapStepIndex = params.process.steps.findIndex(step => step.type === _swap.SwapStepType.SWAP);
     if (swapStepIndex <= -1) {
-      return Promise.reject(new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR));
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR));
     }
     const swapFeeInfo = params.process.totalFee[swapStepIndex];
     const selectedFeeTokenSlug = (_swapFeeInfo$selected = swapFeeInfo.selectedFeeToken) !== null && _swapFeeInfo$selected !== void 0 ? _swapFeeInfo$selected : swapFeeInfo.defaultFeeToken;
@@ -391,8 +274,18 @@ class HydradxHandler {
     };
   }
   async handleSubmitStep(params) {
-    const txHex = params.quote.metadata;
     const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    const toAsset = this.chainService.getAssetBySlug(params.quote.pair.to);
+    const fromAssetId = (0, _utils._getTokenOnChainAssetId)(fromAsset);
+    const toAssetId = (0, _utils._getTokenOnChainAssetId)(toAsset);
+    if (!this.isReady || !this.tradeRouter) {
+      return new _SwapError.SwapError(_swap.SwapErrorType.UNKNOWN);
+    }
+    const parsedFromAmount = new _bignumber.default(params.quote.fromAmount).shiftedBy(-1 * (0, _utils._getAssetDecimals)(fromAsset)).toString();
+    const quoteResponse = await this.tradeRouter.getBestSell(fromAssetId, toAssetId, parsedFromAmount);
+    const toAmount = quoteResponse.amountOut;
+    const minReceive = toAmount.times(1 - params.slippage).integerValue();
+    const txHex = quoteResponse.toTx(minReceive).hex;
     const substrateApi = this.chainService.getSubstrateApi(this.chain());
     const chainApi = await substrateApi.isReady;
     const txData = {
@@ -442,12 +335,12 @@ class HydradxHandler {
     const type = process.steps[currentStep].type;
     switch (type) {
       case _serviceBase.CommonStepType.DEFAULT:
-        return Promise.reject(new _TransactionError.TransactionError(_types2.BasicTxErrorType.UNSUPPORTED));
+        return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
       case _serviceBase.CommonStepType.XCM:
         return this.handleXcmStep(params);
       case _serviceBase.CommonStepType.SET_FEE_TOKEN:
         return this.handleSetFeeStep(params);
-      case _swap2.SwapStepType.SWAP:
+      case _swap.SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       default:
         return this.handleSubmitStep(params);
@@ -457,7 +350,7 @@ class HydradxHandler {
     const amount = params.selectedQuote.fromAmount;
     const bnAmount = new _bignumber.default(amount);
     if (bnAmount.lte(0)) {
-      return [new _TransactionError.TransactionError(_types2.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+      return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
     }
     let isXcmOk = false;
     for (const [index, step] of params.process.steps.entries()) {
@@ -482,66 +375,6 @@ class HydradxHandler {
     }
     return [];
   }
-  async validateSwapRequest(request) {
-    const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
-    const toAsset = this.chainService.getAssetBySlug(request.pair.to);
-    const fromAssetId = (0, _utils._getTokenOnChainAssetId)(fromAsset);
-    const toAssetId = (0, _utils._getTokenOnChainAssetId)(toAsset);
-    try {
-      var _this$tradeRouter, _this$tradeRouter2;
-      // todo: might need to optimize for performance, but prioritize safety for now
-      const allAssets = await ((_this$tradeRouter = this.tradeRouter) === null || _this$tradeRouter === void 0 ? void 0 : _this$tradeRouter.getAllAssets());
-      if (!allAssets) {
-        return {
-          error: _swap2.SwapErrorType.UNKNOWN
-        };
-      }
-      const supportedFromAsset = allAssets.find(asset => asset.id === fromAssetId && asset.symbol === fromAsset.symbol);
-      const supportedToAsset = allAssets.find(asset => asset.id === toAssetId && asset.symbol === toAsset.symbol);
-      if (!supportedFromAsset || !supportedToAsset) {
-        return {
-          error: _swap2.SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      const assetPairs = await ((_this$tradeRouter2 = this.tradeRouter) === null || _this$tradeRouter2 === void 0 ? void 0 : _this$tradeRouter2.getAssetPairs(fromAssetId));
-      if (!assetPairs) {
-        return {
-          error: _swap2.SwapErrorType.UNKNOWN
-        };
-      }
-      const pairedToAsset = assetPairs.find(supportedToAsset => supportedToAsset.id === toAssetId && supportedToAsset.symbol === toAsset.symbol);
-      if (!pairedToAsset) {
-        return {
-          error: _swap2.SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      if (!(fromAsset.originChain === this.chain() && toAsset.originChain === this.chain())) {
-        return {
-          error: _swap2.SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      if (!fromAssetId || !toAssetId) {
-        return {
-          error: _swap2.SwapErrorType.UNKNOWN
-        };
-      }
-      const bnAmount = new _bignumber.default(request.fromAmount);
-      if (bnAmount.lte(0)) {
-        return {
-          error: _swap2.SwapErrorType.AMOUNT_CANNOT_BE_ZERO
-        };
-      }
-      return {
-        metadata: {
-          chain: this.chainService.getChainInfoByKey(this.chain())
-        }
-      };
-    } catch (e) {
-      return {
-        error: _swap2.SwapErrorType.UNKNOWN
-      };
-    }
-  }
   get referralCode() {
     if (this.isTestnet) {
       return HYDRADX_TESTNET_SUBWALLET_REFERRAL_CODE;

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

@@ -7,7 +7,6 @@ exports.simpleSwapApiKey = exports.SimpleSwapHandler = void 0;
 var _SwapError = require("@subwallet/extension-base/background/errors/SwapError");
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
-var _swap = require("@subwallet/extension-base/core/logic-validation/swap");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _types = require("@subwallet/extension-base/types");
 var _utils2 = require("@subwallet/extension-base/utils");
@@ -29,72 +28,6 @@ const toBNString = (input, decimal) => {
   const raw = new _bignumber.BigNumber(input);
   return raw.shiftedBy(decimal).integerValue(_bignumber.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 = _utils3.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[fromAsset.slug];
-  const toSymbol = _utils3.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[toAsset.slug];
-  const assetDecimals = (0, _utils._getAssetDecimals)(fromAsset);
-  if (!fromSymbol || !toSymbol) {
-    throw new _SwapError.SwapError(_types.SwapErrorType.ASSET_NOT_SUPPORTED);
-  }
-  const formatedAmount = (0, _utils2.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.SwapError(_types.SwapErrorType.ERROR_FETCHING_QUOTE);
-    }
-    const resToAmount = await response.json();
-    const toAmount = toBNString(resToAmount, (0, _utils._getAssetDecimals)(toAsset));
-    const bnToAmount = new _bignumber.default(toAmount);
-    const walletFeeRate = 4 / 1000;
-    const toAmountBeforeFee = bnToAmount.dividedBy(new _bignumber.default(1 - walletFeeRate));
-    const walletFeeAmount = toAmountBeforeFee.multipliedBy(4).dividedBy(1000).toString();
-    return {
-      toAmount,
-      walletFeeAmount
-    };
-  } catch (err) {
-    console.error('Error:', err);
-    throw new _SwapError.SwapError(_types.SwapErrorType.ERROR_FETCHING_QUOTE);
-  }
-}
 const createSwapRequest = async params => {
   const fromDecimals = (0, _utils._getAssetDecimals)(params.fromAsset);
   const toDecimals = (0, _utils._getAssetDecimals)(params.toAsset);
@@ -178,70 +111,6 @@ 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.SwapError(_types.SwapErrorType.UNKNOWN);
-      }
-      const earlyValidation = await this.validateSwapRequest(request);
-      const metadata = earlyValidation.metadata;
-      if (earlyValidation.error) {
-        return (0, _swap._getSimpleSwapEarlyValidationError)(earlyValidation.error, metadata);
-      }
-      const {
-        toAmount,
-        walletFeeAmount
-      } = await getEstimate(request, fromAsset, toAsset);
-      const fromAmount = request.fromAmount;
-      const rate = (0, _utils3.calculateSwapRate)(request.fromAmount, toAmount, fromAsset, toAsset);
-      const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
-      const fromChainNativeTokenSlug = (0, _utils._getChainNativeTokenSlug)(fromChain);
-      const defaultFeeToken = (0, _utils._isNativeToken)(fromAsset) ? fromAsset.slug : fromChainNativeTokenSlug;
-      const chainType = (0, _utils._isChainSubstrateCompatible)(fromChain) ? _KoniTypes.ChainType.SUBSTRATE : _KoniTypes.ChainType.EVM;
-      let api;
-      if (chainType === _KoniTypes.ChainType.SUBSTRATE) {
-        api = this.chainService.getSubstrateApi(fromChain.slug);
-      } else {
-        api = this.chainService.getEvmApi(fromChain.slug);
-      }
-      const networkFeeAmount = await (0, _token.getTransferMockTxFee)(request.address, fromChain, fromAsset, api);
-      const networkFee = {
-        tokenSlug: fromChainNativeTokenSlug,
-        amount: networkFeeAmount.toString(),
-        feeType: _types.SwapFeeType.NETWORK_FEE
-      };
-      const walletFee = {
-        tokenSlug: toAsset.slug,
-        amount: walletFeeAmount,
-        feeType: _types.SwapFeeType.WALLET_FEE
-      };
-      return {
-        pair: request.pair,
-        fromAmount,
-        toAmount,
-        rate,
-        provider: this.providerInfo,
-        aliveUntil: +Date.now() + (_utils3.SWAP_QUOTE_TIMEOUT_MAP[this.slug] || _utils3.SWAP_QUOTE_TIMEOUT_MAP.default),
-        minSwap: toBNString(metadata.minSwap.value, (0, _utils._getAssetDecimals)(fromAsset)),
-        maxSwap: toBNString((_metadata$maxSwap = metadata.maxSwap) === null || _metadata$maxSwap === void 0 ? void 0 : _metadata$maxSwap.value, (0, _utils._getAssetDecimals)(fromAsset)),
-        estimatedArrivalTime: 3600,
-        isLowLiquidity: false,
-        feeInfo: {
-          feeComponent: [networkFee, walletFee],
-          defaultFeeToken,
-          feeOptions: [defaultFeeToken]
-        },
-        route: {
-          path: [fromAsset.slug, toAsset.slug]
-        }
-      };
-    } catch (e) {
-      return new _SwapError.SwapError(_types.SwapErrorType.UNKNOWN);
-    }
-  }
   generateOptimalProcess(params) {
     return this.swapBaseHandler.generateOptimalProcess(params, [this.getSubmitStep.bind(this)]);
   }
@@ -255,96 +124,6 @@ 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: _types.SwapErrorType.ERROR_FETCHING_QUOTE
-        };
-      }
-      const fromSymbol = _utils3.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[fromAsset.slug];
-      const toSymbol = _utils3.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[toAsset.slug];
-      if (!fromSymbol || !toSymbol) {
-        return {
-          error: _types.SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      try {
-        const swapList = await fetchSwapList({
-          fromSymbol
-        });
-        if (!swapList.includes(toSymbol)) {
-          return {
-            error: _types.SwapErrorType.ASSET_NOT_SUPPORTED
-          };
-        }
-      } catch (err) {
-        console.error('Error:', err);
-      }
-      const ranges = await fetchRanges({
-        fromSymbol,
-        toSymbol
-      });
-      const {
-        max,
-        min
-      } = ranges;
-      const bnMin = toBNString(min, (0, _utils._getAssetDecimals)(fromAsset));
-      const bnAmount = BigInt(request.fromAmount);
-      if (bnAmount < BigInt(bnMin)) {
-        return {
-          error: _types.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, (0, _utils._getAssetDecimals)(fromAsset)))) {
-        return {
-          error: _types.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: _types.SwapErrorType.UNKNOWN
-      };
-    }
-  }
   async handleSwapProcess(params) {
     const {
       currentStep,
@@ -414,7 +193,7 @@ class SimpleSwapHandler {
     if (chainType === _KoniTypes.ChainType.SUBSTRATE) {
       const chainApi = this.chainService.getSubstrateApi(chainInfo.slug);
       const substrateApi = await chainApi.isReady;
-      const [submittableExtrinsic] = await (0, _token.createTransferExtrinsic)({
+      const [submittableExtrinsic] = await (0, _token.createSubstrateExtrinsic)({
         from: address,
         networkKey: chainInfo.slug,
         substrateApi,