@subwallet/extension-base 1.3.10-0 → 1.3.11-0

package/cjs/services/transaction-service/utils.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getChainflipExplorerLink = getChainflipExplorerLink;
 exports.getExplorerLink = getExplorerLink;
+exports.getSimpleSwapExplorerLink = getSimpleSwapExplorerLink;
 exports.parseTransactionData = parseTransactionData;
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
@@ -54,7 +55,7 @@ function getBlockExplorerTxRoute(chainInfo) {
   if (['aventus', 'deeper_network'].includes(chainInfo.slug)) {
     return 'transaction';
   }
-  if (['invarch'].includes(chainInfo.slug)) {
+  if (['invarch', 'tangle'].includes(chainInfo.slug)) {
     return '#/extrinsics';
   }
   return 'extrinsic';
@@ -70,6 +71,9 @@ function getExplorerLink(chainInfo, value, type) {
       return undefined;
     }
     const route = getBlockExplorerTxRoute(chainInfo);
+    if (chainInfo.slug === 'tangle') {
+      return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}extrinsic/${value}${route}/${value}`;
+    }
     return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}${route}/${value}`;
   }
   return undefined;
@@ -77,4 +81,8 @@ function getExplorerLink(chainInfo, value, type) {
 function getChainflipExplorerLink(data, chainInfo) {
   const chainflipDomain = (0, _utils._isChainTestNet)(chainInfo) ? _utils2.CHAIN_FLIP_TESTNET_EXPLORER : _utils2.CHAIN_FLIP_MAINNET_EXPLORER;
   return `${chainflipDomain}/channels/${data.depositChannelId}`;
+}
+function getSimpleSwapExplorerLink(data) {
+  const simpleswapDomain = _utils2.SIMPLE_SWAP_EXPLORER;
+  return `${simpleswapDomain}/exchange?id=${data.id}`;
 }

package/cjs/types/swap/index.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports._SUPPORTED_SWAP_PROVIDERS = exports.SwapStepType = exports.SwapProviderId = exports.SwapFeeType = exports.SwapErrorType = exports.CHAINFLIP_SLIPPAGE = void 0;
+exports._SUPPORTED_SWAP_PROVIDERS = exports.SwapStepType = exports.SwapProviderId = exports.SwapFeeType = exports.SwapErrorType = exports.SIMPLE_SWAP_SLIPPAGE = exports.CHAINFLIP_SLIPPAGE = void 0;
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 // core
@@ -21,6 +21,7 @@ exports.SwapErrorType = SwapErrorType;
   SwapErrorType["NOT_ENOUGH_LIQUIDITY"] = "NOT_ENOUGH_LIQUIDITY";
   SwapErrorType["MAKE_POOL_NOT_ENOUGH_EXISTENTIAL_DEPOSIT"] = "MAKE_POOL_NOT_ENOUGH_EXISTENTIAL_DEPOSIT";
   SwapErrorType["AMOUNT_CANNOT_BE_ZERO"] = "AMOUNT_CANNOT_BE_ZERO";
+  SwapErrorType["NOT_MEET_MIN_EXPECTED"] = "NOT_MEET_MIN_EXPECTED";
 })(SwapErrorType || (exports.SwapErrorType = SwapErrorType = {}));
 let SwapStepType;
 exports.SwapStepType = SwapStepType;
@@ -37,8 +38,9 @@ exports.SwapProviderId = SwapProviderId;
   SwapProviderId["POLKADOT_ASSET_HUB"] = "POLKADOT_ASSET_HUB";
   SwapProviderId["KUSAMA_ASSET_HUB"] = "KUSAMA_ASSET_HUB";
   SwapProviderId["ROCOCO_ASSET_HUB"] = "ROCOCO_ASSET_HUB";
+  SwapProviderId["SIMPLE_SWAP"] = "SIMPLE_SWAP";
 })(SwapProviderId || (exports.SwapProviderId = SwapProviderId = {}));
-const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET, SwapProviderId.HYDRADX_TESTNET, SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB, SwapProviderId.ROCOCO_ASSET_HUB];
+const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET, SwapProviderId.HYDRADX_TESTNET, SwapProviderId.POLKADOT_ASSET_HUB, SwapProviderId.KUSAMA_ASSET_HUB, SwapProviderId.ROCOCO_ASSET_HUB, SwapProviderId.SIMPLE_SWAP];
 exports._SUPPORTED_SWAP_PROVIDERS = _SUPPORTED_SWAP_PROVIDERS;
 // process handling
 let SwapFeeType;
@@ -49,4 +51,6 @@ exports.SwapFeeType = SwapFeeType;
   SwapFeeType["WALLET_FEE"] = "WALLET_FEE";
 })(SwapFeeType || (exports.SwapFeeType = SwapFeeType = {}));
 const CHAINFLIP_SLIPPAGE = 0.02; // Example: 0.01 for 1%
-exports.CHAINFLIP_SLIPPAGE = CHAINFLIP_SLIPPAGE;
+exports.CHAINFLIP_SLIPPAGE = CHAINFLIP_SLIPPAGE;
+const SIMPLE_SWAP_SLIPPAGE = 0.05;
+exports.SIMPLE_SWAP_SLIPPAGE = SIMPLE_SWAP_SLIPPAGE;

package/cjs/utils/number.js

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.toBNString = exports.formatNumber = exports.balanceNoPrefixFormater = exports.balanceFormatter = exports.PREDEFINED_FORMATTER = exports.BN_ZERO = exports.BN_WEI = exports.BN_TEN = exports.BN_ONE = void 0;
+exports.formatNumber = exports.balanceNoPrefixFormater = exports.balanceFormatter = exports.PREDEFINED_FORMATTER = exports.BN_ZERO = exports.BN_WEI = exports.BN_TEN = exports.BN_ONE = void 0;
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
@@ -195,12 +195,17 @@ exports.balanceNoPrefixFormater = balanceNoPrefixFormater;
 const PREDEFINED_FORMATTER = {
   balance: balanceFormatter
 };
+
+/** @function formatNumber
+ * Convert number to a formatted string by dividing by 10^decimal
+ * @param {string | number | BigNumber} input - Input number
+ * @param {number} decimal - Decimal number
+ * @param {NumberFormatter} [formatter] - Formatter function
+ * - Default: balanceFormatter: With number > 1, show decimal with 2 numbers,
+ * with number < 1, show decimal with 6 (default) number
+ * @param {Record<string, number>} [metadata] - Metadata for formatter
+ */
 exports.PREDEFINED_FORMATTER = PREDEFINED_FORMATTER;
-const toBNString = (input, decimal) => {
-  const raw = new _bignumber.default(input);
-  return raw.multipliedBy(BN_TEN.pow(decimal)).toFixed();
-};
-exports.toBNString = toBNString;
 const formatNumber = function (input, decimal) {
   let formatter = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : balanceFormatter;
   let metadata = arguments.length > 3 ? arguments[3] : undefined;

package/core/logic-validation/swap.d.ts

@@ -1,10 +1,11 @@
 import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
-import { AssetHubPreValidationMetadata, ChainflipPreValidationMetadata, HydradxPreValidationMetadata, SwapErrorType } from '@subwallet/extension-base/types/swap';
+import { AssetHubPreValidationMetadata, ChainflipPreValidationMetadata, HydradxPreValidationMetadata, SimpleSwapValidationMetadata, SwapErrorType } from '@subwallet/extension-base/types/swap';
 export declare function _validateBalanceToSwapOnAssetHub(fromToken: _ChainAsset, feeToken: _ChainAsset, feeTokenChainInfo: _ChainInfo, feeAmount: string, fromTokenBalance: string, feeTokenBalance: string, swapAmount: string, isXcmOk: boolean, minSwap?: string): TransactionError | undefined;
 export declare function _validateBalanceToSwap(fromToken: _ChainAsset, feeToken: _ChainAsset, feeTokenChainInfo: _ChainInfo, feeAmount: string, fromTokenBalance: string, feeTokenBalance: string, swapAmount: string, isXcmOk: boolean, minSwap?: string): TransactionError | undefined;
 export declare function _validateSwapRecipient(destChainInfo: _ChainInfo, recipient: string): TransactionError | undefined;
 export declare function _getChainflipEarlyValidationError(error: SwapErrorType, metadata: ChainflipPreValidationMetadata): SwapError;
 export declare function _getEarlyHydradxValidationError(error: SwapErrorType, metadata: HydradxPreValidationMetadata): SwapError;
 export declare function _getEarlyAssetHubValidationError(error: SwapErrorType, metadata: AssetHubPreValidationMetadata): SwapError;
+export declare function _getSimpleSwapEarlyValidationError(error: SwapErrorType, metadata: SimpleSwapValidationMetadata): SwapError;

package/core/logic-validation/swap.js

@@ -137,4 +137,30 @@ export function _getEarlyAssetHubValidationError(error, metadata) {
     default:
       return new SwapError(error);
   }
+}
+export function _getSimpleSwapEarlyValidationError(error, metadata) {
+  // todo: support more providers
+  switch (error) {
+    case SwapErrorType.NOT_MEET_MIN_SWAP:
+      {
+        const message = `Amount too low. Increase your amount above ${metadata.minSwap.value} ${metadata.minSwap.symbol} and try again`;
+        return new SwapError(error, message);
+      }
+    case SwapErrorType.SWAP_EXCEED_ALLOWANCE:
+      {
+        if (metadata.maxSwap) {
+          return new SwapError(error, `Amount too high. Lower your amount below ${metadata.maxSwap.value} ${metadata.maxSwap.symbol} and try again`);
+        } else {
+          return new SwapError(error, 'Amount too high. Lower your amount and try again');
+        }
+      }
+    case SwapErrorType.ASSET_NOT_SUPPORTED:
+      return new SwapError(error, 'This swap pair is not supported');
+    case SwapErrorType.UNKNOWN:
+      return new SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
+    case SwapErrorType.ERROR_FETCHING_QUOTE:
+      return new SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
+    default:
+      return new SwapError(error);
+  }
 }

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.3.10-0",
+  "version": "1.3.11-0",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -1774,6 +1774,11 @@
       "require": "./cjs/services/swap-service/handler/hydradx-handler.js",
       "default": "./services/swap-service/handler/hydradx-handler.js"
     },
+    "./services/swap-service/handler/simpleswap-handler": {
+      "types": "./services/swap-service/handler/simpleswap-handler.d.ts",
+      "require": "./cjs/services/swap-service/handler/simpleswap-handler.js",
+      "default": "./services/swap-service/handler/simpleswap-handler.js"
+    },
     "./services/swap-service/utils": {
       "types": "./services/swap-service/utils.d.ts",
       "require": "./cjs/services/swap-service/utils.js",
@@ -2491,11 +2496,11 @@
     "@reduxjs/toolkit": "^1.9.1",
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.8.9",
-    "@subwallet/chain-list": "0.2.95-beta.1",
-    "@subwallet/extension-base": "^1.3.10-0",
-    "@subwallet/extension-chains": "^1.3.10-0",
-    "@subwallet/extension-dapp": "^1.3.10-0",
-    "@subwallet/extension-inject": "^1.3.10-0",
+    "@subwallet/chain-list": "0.2.96",
+    "@subwallet/extension-base": "^1.3.11-0",
+    "@subwallet/extension-chains": "^1.3.11-0",
+    "@subwallet/extension-dapp": "^1.3.11-0",
+    "@subwallet/extension-inject": "^1.3.11-0",
     "@subwallet/keyring": "^0.1.8-beta.0",
     "@subwallet/ui-keyring": "^0.1.8-beta.0",
     "@ton/core": "^0.56.3",

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.3.10-0'
+  version: '1.3.11-0'
 };

package/services/chain-service/utils/patch.js

@@ -5,7 +5,7 @@ const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev';
 const fetchFile = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'list.json' : 'preview.json';
-const ChainListVersion = '0.2.95'; // update this when build chainlist
+const ChainListVersion = '0.2.96'; // update this when build chainlist
 
 // todo: move this interface to chainlist
 

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

@@ -362,7 +362,6 @@ export class ChainflipSwapHandler {
       }
     });
 
-    console.log('depositAddressResp', depositAddressResponse);
     const txData = {
       address,
       provider: this.providerInfo,

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

@@ -0,0 +1,24 @@
+import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo, OptimalSwapPathParams, SwapEarlyValidation, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { BalanceService } from '../../balance-service';
+import { ChainService } from '../../chain-service';
+import { SwapBaseInterface } from './base-handler';
+export declare const simpleSwapApiKey: string;
+export declare class SimpleSwapHandler implements SwapBaseInterface {
+    private swapBaseHandler;
+    providerSlug: SwapProviderId;
+    constructor(chainService: ChainService, balanceService: BalanceService);
+    validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    get chainService(): ChainService;
+    get balanceService(): BalanceService;
+    get providerInfo(): import("@subwallet/extension-base/types").SwapProvider;
+    get name(): string;
+    get slug(): string;
+    getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalPath>;
+    getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
+    validateSwapRequest(request: SwapRequest): Promise<SwapEarlyValidation>;
+    handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+}

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

@@ -0,0 +1,434 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+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 { _reformatAddressWithChain, formatNumber } from '@subwallet/extension-base/utils';
+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 { SwapBaseHandler } from "./base-handler.js";
+const apiUrl = 'https://api.simpleswap.io';
+export const simpleSwapApiKey = process.env.SIMPLE_SWAP_API_KEY || '';
+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);
+  const formatedAmount = formatNumber(params.fromAmount, fromDecimals, s => s);
+  const requestBody = {
+    fixed: false,
+    currency_from: params.fromSymbol,
+    currency_to: params.toSymbol,
+    amount: formatedAmount,
+    // Convert to small number due to require of api
+    address_to: params.receiver,
+    extra_id_to: '',
+    user_refund_address: params.sender,
+    user_refund_extra_id: ''
+  };
+  const response = await fetch(`${apiUrl}/create_exchange?api_key=${simpleSwapApiKey}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json'
+    },
+    body: JSON.stringify(requestBody)
+  });
+  const depositAddressResponse = await response.json();
+  return {
+    id: depositAddressResponse.id,
+    addressFrom: depositAddressResponse.address_from,
+    amountTo: toBNString(depositAddressResponse.amount_to, toDecimals)
+  };
+};
+export class SimpleSwapHandler {
+  constructor(chainService, balanceService) {
+    this.swapBaseHandler = new SwapBaseHandler({
+      chainService,
+      balanceService,
+      providerName: 'SimpleSwap',
+      providerSlug: SwapProviderId.SIMPLE_SWAP
+    });
+    this.providerSlug = SwapProviderId.SIMPLE_SWAP;
+  }
+  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.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+          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 [];
+  }
+  get chainService() {
+    return this.swapBaseHandler.chainService;
+  }
+  get balanceService() {
+    return this.swapBaseHandler.balanceService;
+  }
+  get providerInfo() {
+    return this.swapBaseHandler.providerInfo;
+  }
+  get name() {
+    return this.swapBaseHandler.name;
+  }
+  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]);
+  }
+  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 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,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case CommonStepType.DEFAULT:
+        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+      case SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  async handleSubmitStep(params) {
+    const {
+      address,
+      quote,
+      recipient
+    } = params;
+    const pair = quote.pair;
+    const fromAsset = this.chainService.getAssetBySlug(pair.from);
+    const toAsset = this.chainService.getAssetBySlug(pair.to);
+    const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const toChainInfo = this.chainService.getChainInfoByKey(toAsset.originChain);
+    const chainType = _isChainSubstrateCompatible(chainInfo) ? ChainType.SUBSTRATE : ChainType.EVM;
+    const sender = _reformatAddressWithChain(address, chainInfo);
+    const receiver = _reformatAddressWithChain(recipient !== null && recipient !== void 0 ? recipient : sender, toChainInfo);
+    const fromSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[fromAsset.slug];
+    const toSymbol = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[toAsset.slug];
+    const {
+      fromAmount
+    } = quote;
+    const {
+      addressFrom,
+      amountTo,
+      id
+    } = await createSwapRequest({
+      fromSymbol,
+      toSymbol,
+      fromAmount,
+      fromAsset,
+      receiver,
+      sender,
+      toAsset
+    });
+
+    // Validate the amount to be swapped
+    const rate = BigN(amountTo).div(BigN(quote.toAmount)).multipliedBy(100);
+    if (rate.lt(95)) {
+      throw new SwapError(SwapErrorType.NOT_MEET_MIN_EXPECTED);
+    }
+
+    // Can modify quote.toAmount to amountTo after confirm real amount received
+
+    const txData = {
+      id: id,
+      address,
+      provider: this.providerInfo,
+      quote: params.quote,
+      slippage: params.slippage,
+      recipient: receiver,
+      process: params.process
+    };
+    let extrinsic;
+    if (chainType === ChainType.SUBSTRATE) {
+      const chainApi = this.chainService.getSubstrateApi(chainInfo.slug);
+      const substrateApi = await chainApi.isReady;
+      const [submittableExtrinsic] = await createTransferExtrinsic({
+        from: address,
+        networkKey: chainInfo.slug,
+        substrateApi,
+        to: addressFrom,
+        tokenInfo: fromAsset,
+        transferAll: false,
+        value: quote.fromAmount
+      });
+      extrinsic = submittableExtrinsic;
+    } else {
+      if (_isNativeToken(fromAsset)) {
+        const [transactionConfig] = await getEVMTransactionObject(chainInfo, address, addressFrom, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        extrinsic = transactionConfig;
+      } else {
+        const [transactionConfig] = await getERC20TransactionObject(_getContractAddressOfToken(fromAsset), chainInfo, address, addressFrom, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        extrinsic = transactionConfig;
+      }
+    }
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic,
+      transferNativeAmount: _isNativeToken(fromAsset) ? quote.fromAmount : '0',
+      extrinsicType: ExtrinsicType.SWAP,
+      chainType
+    };
+  }
+}