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

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

@@ -1,39 +1,23 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { SwapSDK } from '@chainflip/sdk/swap';
 import { COMMON_ASSETS } from '@subwallet/chain-list';
-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 { _getChainflipEarlyValidationError } from '@subwallet/extension-base/core/logic-validation/swap';
 import { getERC20TransactionObject, getEVMTransactionObject } from '@subwallet/extension-base/services/balance-service/transfer/smart-contract';
-import { createTransferExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/token';
-import { _getAssetDecimals, _getAssetSymbol, _getChainNativeTokenSlug, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken, _isSmartContractToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { createSubstrateExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/token';
+import { _getAssetSymbol, _getContractAddressOfToken, _isChainSubstrateCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
-import { calculateSwapRate, CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING, CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING, CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING, CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING, getChainflipOptions, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
+import { getChainflipSwap } from '@subwallet/extension-base/services/swap-service/utils';
 import { BasicTxErrorType } from '@subwallet/extension-base/types';
 import { CommonStepType } from '@subwallet/extension-base/types/service-base';
-import { SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
+import { SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
+import { _reformatAddressWithChain } from '@subwallet/extension-base/utils';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigNumber from 'bignumber.js';
-var ChainflipFeeType;
-(function (ChainflipFeeType) {
-  ChainflipFeeType["INGRESS"] = "INGRESS";
-  ChainflipFeeType["NETWORK"] = "NETWORK";
-  ChainflipFeeType["EGRESS"] = "EGRESS";
-  ChainflipFeeType["BOOST"] = "BOOST";
-  ChainflipFeeType["BROKER"] = "BROKER";
-})(ChainflipFeeType || (ChainflipFeeType = {}));
 const INTERMEDIARY_MAINNET_ASSET_SLUG = COMMON_ASSETS.USDC_ETHEREUM;
 const INTERMEDIARY_TESTNET_ASSET_SLUG = COMMON_ASSETS.USDC_SEPOLIA;
 export const CHAINFLIP_BROKER_API = process.env.CHAINFLIP_BROKER_API || '';
-var CHAINFLIP_QUOTE_ERROR;
-(function (CHAINFLIP_QUOTE_ERROR) {
-  CHAINFLIP_QUOTE_ERROR["InsufficientLiquidity"] = "InsufficientLiquidity";
-  CHAINFLIP_QUOTE_ERROR["InsufficientEgress"] = "is lower than minimum egress amount";
-  CHAINFLIP_QUOTE_ERROR["InsufficientIngress"] = "amount is lower than estimated ingress fee";
-})(CHAINFLIP_QUOTE_ERROR || (CHAINFLIP_QUOTE_ERROR = {}));
 export class ChainflipSwapHandler {
   constructor(chainService, balanceService, feeService, isTestnet = true) {
     this.swapBaseHandler = new SwapBaseHandler({
@@ -45,9 +29,7 @@ export class ChainflipSwapHandler {
     });
     this.isTestnet = isTestnet;
     this.providerSlug = isTestnet ? SwapProviderId.CHAIN_FLIP_TESTNET : SwapProviderId.CHAIN_FLIP_MAINNET;
-
-    // @ts-ignore
-    this.swapSdk = new SwapSDK(getChainflipOptions(isTestnet));
+    this.baseUrl = getChainflipSwap(isTestnet);
   }
   get chainService() {
     return this.swapBaseHandler.chainService;
@@ -64,20 +46,6 @@ export class ChainflipSwapHandler {
   get slug() {
     return this.swapBaseHandler.slug;
   }
-  get assetMapping() {
-    if (this.isTestnet) {
-      return CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING;
-    } else {
-      return CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING;
-    }
-  }
-  get chainMapping() {
-    if (this.isTestnet) {
-      return CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING;
-    } else {
-      return CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING;
-    }
-  }
   get intermediaryAssetSlug() {
     if (this.isTestnet) {
       return INTERMEDIARY_TESTNET_ASSET_SLUG;
@@ -85,224 +53,6 @@ export class ChainflipSwapHandler {
       return INTERMEDIARY_MAINNET_ASSET_SLUG;
     }
   }
-  async validateSwapRequest(request) {
-    try {
-      // todo: risk of matching wrong chain, asset can lead to loss of funds
-
-      const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
-      const toAsset = this.chainService.getAssetBySlug(request.pair.to);
-      const srcChain = fromAsset.originChain;
-      const destChain = toAsset.originChain;
-      const isSwapCrossChain = srcChain !== destChain;
-      const srcChainInfo = this.chainService.getChainInfoByKey(srcChain);
-      const srcChainId = this.chainMapping[srcChain];
-      const destChainId = this.chainMapping[destChain];
-      const fromAssetId = _getAssetSymbol(fromAsset);
-      const toAssetId = _getAssetSymbol(toAsset);
-      if (!srcChainId || !destChainId || !fromAssetId || !toAssetId) {
-        return {
-          error: SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      const [supportedDestChains, srcAssets, destAssets] = await Promise.all([this.swapSdk.getChains(srcChainId), this.swapSdk.getAssets(srcChainId), this.swapSdk.getAssets(destChainId)]);
-      const supportedDestChainId = supportedDestChains.find(c => c.chain === destChainId);
-      const srcAssetData = srcAssets.find(a => {
-        if (_isSmartContractToken(fromAsset)) {
-          var _a$contractAddress;
-          return (a === null || a === void 0 ? void 0 : (_a$contractAddress = a.contractAddress) === null || _a$contractAddress === void 0 ? void 0 : _a$contractAddress.toLowerCase()) === _getContractAddressOfToken(fromAsset).toLowerCase() && a.asset === fromAssetId;
-        }
-        return a.asset === fromAssetId;
-      });
-      const destAssetData = destAssets.find(a => {
-        if (_isSmartContractToken(toAsset)) {
-          var _a$contractAddress2;
-          return (a === null || a === void 0 ? void 0 : (_a$contractAddress2 = a.contractAddress) === null || _a$contractAddress2 === void 0 ? void 0 : _a$contractAddress2.toLowerCase()) === _getContractAddressOfToken(toAsset).toLowerCase() && a.asset === toAssetId;
-        }
-        return a.asset === toAssetId;
-      });
-      if (!destAssetData || !srcAssetData || isSwapCrossChain && !supportedDestChainId) {
-        return {
-          error: SwapErrorType.UNKNOWN
-        };
-      }
-      const bnAmount = new BigNumber(request.fromAmount);
-      const bnMinSwap = new BigNumber(srcAssetData.minimumSwapAmount);
-      if (srcAssetData.maximumSwapAmount) {
-        const bnMaxProtocolSwap = new BigNumber(srcAssetData.maximumSwapAmount);
-        if (bnMinSwap.gte(bnMaxProtocolSwap)) {
-          return {
-            error: SwapErrorType.UNKNOWN
-          };
-        }
-        if (bnAmount.gte(bnMaxProtocolSwap)) {
-          return {
-            error: SwapErrorType.SWAP_EXCEED_ALLOWANCE,
-            metadata: {
-              minSwap: {
-                value: srcAssetData.minimumSwapAmount,
-                decimals: _getAssetDecimals(fromAsset),
-                symbol: fromAsset.symbol
-              },
-              maxSwap: {
-                value: bnMaxProtocolSwap.toString(),
-                decimals: _getAssetDecimals(fromAsset),
-                symbol: fromAsset.symbol
-              },
-              chain: srcChainInfo
-            }
-          };
-        }
-      }
-      if (bnAmount.lt(bnMinSwap)) {
-        // might miss case when minSwap is 0
-        return {
-          error: SwapErrorType.NOT_MEET_MIN_SWAP,
-          metadata: {
-            minSwap: {
-              value: srcAssetData.minimumSwapAmount,
-              decimals: _getAssetDecimals(fromAsset),
-              symbol: fromAsset.symbol
-            },
-            maxSwap: {
-              value: srcAssetData.maximumSwapAmount,
-              decimals: _getAssetDecimals(fromAsset),
-              symbol: fromAsset.symbol
-            },
-            chain: srcChainInfo
-          }
-        };
-      }
-      return {
-        metadata: {
-          minSwap: {
-            value: srcAssetData.minimumSwapAmount,
-            decimals: _getAssetDecimals(fromAsset),
-            symbol: fromAsset.symbol
-          },
-          maxSwap: {
-            value: srcAssetData.maximumSwapAmount,
-            decimals: _getAssetDecimals(fromAsset),
-            symbol: fromAsset.symbol
-          },
-          chain: srcChainInfo
-        }
-      };
-    } catch (e) {
-      return {
-        error: SwapErrorType.UNKNOWN
-      };
-    }
-  }
-  parseSwapPath(fromAsset, toAsset) {
-    if (toAsset.slug !== this.intermediaryAssetSlug && fromAsset.slug !== this.intermediaryAssetSlug) {
-      // Chainflip always use USDC as intermediary
-      return [fromAsset.slug, this.intermediaryAssetSlug, toAsset.slug]; // todo: generalize this
-    }
-
-    return [fromAsset.slug, toAsset.slug];
-  }
-  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 = _getChainNativeTokenSlug(fromChain);
-    if (!fromAsset || !toAsset) {
-      return new SwapError(SwapErrorType.UNKNOWN);
-    }
-    const earlyValidation = await this.validateSwapRequest(request);
-    const metadata = earlyValidation.metadata;
-    if (earlyValidation.error) {
-      return _getChainflipEarlyValidationError(earlyValidation.error, metadata);
-    }
-    const srcChainId = this.chainMapping[fromAsset.originChain];
-    const destChainId = this.chainMapping[toAsset.originChain];
-    const fromAssetId = _getAssetSymbol(fromAsset);
-    const toAssetId = _getAssetSymbol(toAsset);
-    try {
-      var _metadata$maxSwap;
-      const quoteResponse = await this.swapSdk.getQuote({
-        srcChain: srcChainId,
-        destChain: destChainId,
-        srcAsset: fromAssetId,
-        destAsset: toAssetId,
-        amount: request.fromAmount
-      });
-      const feeComponent = [];
-      quoteResponse.quote.includedFees.forEach(fee => {
-        switch (fee.type) {
-          case ChainflipFeeType.INGRESS:
-            {
-              feeComponent.push({
-                tokenSlug: fromAsset.slug,
-                amount: fee.amount,
-                feeType: SwapFeeType.NETWORK_FEE
-              });
-              break;
-            }
-
-          // eslint-disable-next-line no-fallthrough
-          case ChainflipFeeType.EGRESS:
-            {
-              feeComponent.push({
-                tokenSlug: toAsset.slug,
-                amount: fee.amount,
-                feeType: SwapFeeType.NETWORK_FEE
-              });
-              break;
-            }
-          case ChainflipFeeType.NETWORK:
-
-          // eslint-disable-next-line no-fallthrough
-          case ChainflipFeeType.BOOST:
-
-          // eslint-disable-next-line no-fallthrough
-          case ChainflipFeeType.BROKER:
-            {
-              feeComponent.push({
-                tokenSlug: this.intermediaryAssetSlug,
-                amount: fee.amount,
-                feeType: SwapFeeType.PLATFORM_FEE
-              });
-              break;
-            }
-        }
-      });
-      const defaultFeeToken = _isNativeToken(fromAsset) ? fromAsset.slug : fromChainNativeTokenSlug;
-      return {
-        pair: request.pair,
-        fromAmount: request.fromAmount,
-        toAmount: quoteResponse.quote.egressAmount.toString(),
-        rate: calculateSwapRate(request.fromAmount, quoteResponse.quote.egressAmount.toString(), fromAsset, toAsset),
-        provider: this.providerInfo,
-        aliveUntil: +Date.now() + (SWAP_QUOTE_TIMEOUT_MAP[this.slug] || SWAP_QUOTE_TIMEOUT_MAP.default),
-        minSwap: metadata.minSwap.value,
-        maxSwap: (_metadata$maxSwap = metadata.maxSwap) === null || _metadata$maxSwap === void 0 ? void 0 : _metadata$maxSwap.value,
-        estimatedArrivalTime: quoteResponse.quote.estimatedDurationSeconds,
-        // in seconds
-        isLowLiquidity: quoteResponse.quote.lowLiquidityWarning,
-        feeInfo: {
-          feeComponent: feeComponent,
-          defaultFeeToken,
-          feeOptions: [defaultFeeToken]
-        },
-        route: {
-          path: this.parseSwapPath(fromAsset, toAsset)
-        }
-      };
-    } catch (e) {
-      var _error$response;
-      const error = e;
-      const errorObj = error === null || error === void 0 ? void 0 : (_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.data;
-      if (errorObj && errorObj.error && errorObj.error.includes(CHAINFLIP_QUOTE_ERROR.InsufficientLiquidity)) {
-        // todo: Chainflip will improve this
-        return new SwapError(SwapErrorType.NOT_ENOUGH_LIQUIDITY);
-      }
-      if (errorObj && errorObj.message && errorObj.message.includes(CHAINFLIP_QUOTE_ERROR.InsufficientLiquidity)) {
-        return new SwapError(SwapErrorType.NOT_ENOUGH_LIQUIDITY);
-      }
-      return new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
-    }
-  }
   async validateSwapProcess(params) {
     const amount = params.selectedQuote.fromAmount;
     const bnAmount = new BigNumber(amount);
@@ -341,48 +91,49 @@ export class ChainflipSwapHandler {
     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(fromAsset.originChain);
     const chainType = _isChainSubstrateCompatible(chainInfo) ? ChainType.SUBSTRATE : ChainType.EVM;
-    const receiver = recipient !== null && recipient !== void 0 ? recipient : address;
-    const srcChainId = this.chainMapping[fromAsset.originChain];
-    const destChainId = this.chainMapping[toAsset.originChain];
+    const receiver = _reformatAddressWithChain(recipient !== null && recipient !== void 0 ? recipient : address, toChainInfo);
     const fromAssetId = _getAssetSymbol(fromAsset);
     const toAssetId = _getAssetSymbol(toAsset);
     const minReceive = new BigNumber(quote.rate).times(1 - slippage).toString();
-    const depositAddressResponse = await this.swapSdk.requestDepositAddress({
-      srcChain: srcChainId,
-      destChain: destChainId,
-      srcAsset: fromAssetId,
-      destAsset: toAssetId,
-      destAddress: receiver,
-      amount: quote.fromAmount,
-      fillOrKillParams: {
-        minPrice: minReceive,
-        // minimum accepted price for swaps through the channel
-        refundAddress: address,
-        // address to which assets are refunded
-        retryDurationBlocks: 100 // 100 blocks * 6 seconds = 10 minutes before deposits are refunded
-      }
+    const depositParams = {
+      destinationAddress: receiver,
+      destinationAsset: toAssetId,
+      minimumPrice: minReceive,
+      // minimum accepted price for swaps through the channel
+      refundAddress: address,
+      // address to which assets are refunded
+      retryDurationInBlocks: '100',
+      // 100 blocks * 6 seconds = 10 minutes before deposits are refunded
+      sourceAsset: fromAssetId
+    };
+    const url = `${this.baseUrl}&${new URLSearchParams(depositParams).toString()}`;
+    const response = await fetch(url, {
+      method: 'GET'
     });
-
+    const data = await response.json();
+    const depositChannelId = `${data.issuedBlock}-${data.network}-${data.channelId}`;
+    const depositAddress = data.address;
     const txData = {
       address,
       provider: this.providerInfo,
       quote: params.quote,
       slippage: params.slippage,
       recipient,
-      depositChannelId: depositAddressResponse.depositChannelId,
-      depositAddress: depositAddressResponse.depositAddress,
+      depositChannelId: depositChannelId,
+      depositAddress: depositAddress,
       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({
+      const [submittableExtrinsic] = await createSubstrateExtrinsic({
         from: address,
         networkKey: chainInfo.slug,
         substrateApi,
-        to: depositAddressResponse.depositAddress,
+        to: depositAddress,
         tokenInfo: fromAsset,
         transferAll: false,
         // always false, because we do not allow swapping all the balance
@@ -397,7 +148,7 @@ export class ChainflipSwapHandler {
           chain: chainInfo.slug,
           evmApi: this.chainService.getEvmApi(chainInfo.slug),
           from: address,
-          to: depositAddressResponse.depositAddress,
+          to: depositAddress,
           value: quote.fromAmount,
           feeInfo,
           transferAll: false
@@ -409,7 +160,7 @@ export class ChainflipSwapHandler {
           chain: chainInfo.slug,
           evmApi: this.chainService.getEvmApi(chainInfo.slug),
           from: address,
-          to: depositAddressResponse.depositAddress,
+          to: depositAddress,
           value: quote.fromAmount,
           feeInfo,
           transferAll: false

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

@@ -1,11 +1,10 @@
-import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BalanceService } from '@subwallet/extension-base/services/balance-service';
 import { ChainService } from '@subwallet/extension-base/services/chain-service';
 import FeeService from '@subwallet/extension-base/services/fee-service/service';
 import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
 import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo } from '@subwallet/extension-base/types/service-base';
-import { OptimalSwapPathParams, SwapEarlyValidation, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+import { OptimalSwapPathParams, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
 export declare class HydradxHandler implements SwapBaseInterface {
     private swapBaseHandler;
     private tradeRouter;
@@ -24,15 +23,11 @@ export declare class HydradxHandler implements SwapBaseInterface {
     getFeeOptionStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined>;
     generateOptimalProcess(params: OptimalSwapPathParams): Promise<CommonOptimalPath>;
-    private getSwapPathErrors;
-    private parseSwapPath;
-    getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
     handleXcmStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSetFeeStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
     validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
-    validateSwapRequest(request: SwapRequest): Promise<SwapEarlyValidation>;
     get referralCode(): "WALLET" | "ASSETHUB";
     get referralAccount(): "7PCsCpkgsHdNaZhv79wCCQ5z97uxVbSeSCtDMUa1eZHKXy4a" | "7LCt6dFqtxzdKVB2648jWW9d85doiFfLSbZJDNAMVJNxh5rJ";
 }

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

@@ -1,24 +1,21 @@
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-import { PoolError, PoolService, TradeRouter } from '@galacticcouncil/sdk';
+import { PoolService, TradeRouter } from '@galacticcouncil/sdk';
 import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
-import { _AssetType } from '@subwallet/chain-list/types';
 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 { XCM_MIN_AMOUNT_RATIO } from '@subwallet/extension-base/constants';
-import { _getEarlyHydradxValidationError } from '@subwallet/extension-base/core/logic-validation/swap';
 import { createXcmExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
 import { _getAssetDecimals, _getChainNativeTokenSlug, _getTokenOnChainAssetId, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
 import { SwapBaseHandler } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
-import { calculateSwapRate, getSwapAlternativeAsset, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
+import { getSwapAlternativeAsset } from '@subwallet/extension-base/services/swap-service/utils';
 import { BasicTxErrorType } from '@subwallet/extension-base/types';
 import { CommonStepType } from '@subwallet/extension-base/types/service-base';
 import { SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
 import { getId } from '@subwallet/extension-base/utils/getId';
 import BigNumber from 'bignumber.js';
-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';
@@ -195,120 +192,6 @@ export 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(), [_AssetType.NATIVE, _AssetType.LOCAL]);
-    const swapAssetIdMap = Object.values(swapAssets).reduce((accumulator, asset) => {
-      return {
-        ...accumulator,
-        [_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 = _getChainNativeTokenSlug(fromChain);
-    if (!this.isReady || !this.tradeRouter) {
-      return new SwapError(SwapErrorType.UNKNOWN);
-    }
-    const earlyValidation = await this.validateSwapRequest(request);
-    if (earlyValidation.error) {
-      const metadata = earlyValidation.metadata;
-      return _getEarlyHydradxValidationError(earlyValidation.error, metadata);
-    }
-    try {
-      const fromAssetId = _getTokenOnChainAssetId(fromAsset);
-      const toAssetId = _getTokenOnChainAssetId(toAsset);
-      const parsedFromAmount = new BigNumber(request.fromAmount).shiftedBy(-1 * _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: SwapFeeType.NETWORK_FEE
-      };
-      const tradeFee = {
-        tokenSlug: toAsset.slug,
-        // fee is subtracted from receiving amount
-        amount: quoteResponse.tradeFee.toString(),
-        feeType: 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 PoolError.InsufficientTradingAmount:
-            return new SwapError(SwapErrorType.NOT_MEET_MIN_SWAP);
-          case PoolError.TradeNotAllowed:
-            return new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
-          case PoolError.MaxInRatioExceeded:
-            return new SwapError(SwapErrorType.NOT_ENOUGH_LIQUIDITY);
-          case PoolError.UnknownError:
-            return new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
-          case PoolError.MaxOutRatioExceeded:
-            return new SwapError(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: calculateSwapRate(request.fromAmount, toAmount.toString(), fromAsset, toAsset),
-        provider: this.providerInfo,
-        aliveUntil: +Date.now() + (SWAP_QUOTE_TIMEOUT_MAP[this.slug] || 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(SwapErrorType.ERROR_FETCHING_QUOTE);
-    }
-  }
   async handleXcmStep(params) {
     const pair = params.quote.pair;
     const alternativeAssetSlug = getSwapAlternativeAsset(pair);
@@ -383,8 +266,18 @@ export 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 = _getTokenOnChainAssetId(fromAsset);
+    const toAssetId = _getTokenOnChainAssetId(toAsset);
+    if (!this.isReady || !this.tradeRouter) {
+      return new SwapError(SwapErrorType.UNKNOWN);
+    }
+    const parsedFromAmount = new BigNumber(params.quote.fromAmount).shiftedBy(-1 * _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 = {
@@ -474,66 +367,6 @@ export class HydradxHandler {
     }
     return [];
   }
-  async validateSwapRequest(request) {
-    const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
-    const toAsset = this.chainService.getAssetBySlug(request.pair.to);
-    const fromAssetId = _getTokenOnChainAssetId(fromAsset);
-    const toAssetId = _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: 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: 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: SwapErrorType.UNKNOWN
-        };
-      }
-      const pairedToAsset = assetPairs.find(supportedToAsset => supportedToAsset.id === toAssetId && supportedToAsset.symbol === toAsset.symbol);
-      if (!pairedToAsset) {
-        return {
-          error: SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      if (!(fromAsset.originChain === this.chain() && toAsset.originChain === this.chain())) {
-        return {
-          error: SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      if (!fromAssetId || !toAssetId) {
-        return {
-          error: SwapErrorType.UNKNOWN
-        };
-      }
-      const bnAmount = new BigNumber(request.fromAmount);
-      if (bnAmount.lte(0)) {
-        return {
-          error: SwapErrorType.AMOUNT_CANNOT_BE_ZERO
-        };
-      }
-      return {
-        metadata: {
-          chain: this.chainService.getChainInfoByKey(this.chain())
-        }
-      };
-    } catch (e) {
-      return {
-        error: SwapErrorType.UNKNOWN
-      };
-    }
-  }
   get referralCode() {
     if (this.isTestnet) {
       return HYDRADX_TESTNET_SUBWALLET_REFERRAL_CODE;

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

@@ -1,7 +1,6 @@
-import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import FeeService from '@subwallet/extension-base/services/fee-service/service';
-import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo, OptimalSwapPathParams, SwapEarlyValidation, SwapProviderId, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import { BaseStepDetail, CommonOptimalPath, CommonStepFeeInfo, OptimalSwapPathParams, SwapProviderId, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
 import { BalanceService } from '../../balance-service';
 import { ChainService } from '../../chain-service';
 import { SwapBaseInterface } from './base-handler';
@@ -16,10 +15,8 @@ export declare class SimpleSwapHandler implements SwapBaseInterface {
     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>;
 }