@subwallet/extension-base 1.1.53-0 → 1.1.53-beta.0

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

@@ -0,0 +1,38 @@
+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 { BaseStepDetail } from '@subwallet/extension-base/types/service-base';
+import { GenSwapStepFunc, OptimalSwapPath, OptimalSwapPathParams, SwapEarlyValidation, SwapFeeInfo, SwapProvider, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+export interface SwapBaseInterface {
+    getSwapQuote: (request: SwapRequest) => Promise<SwapQuote | SwapError>;
+    generateOptimalProcess: (params: OptimalSwapPathParams) => Promise<OptimalSwapPath>;
+    getSubmitStep: (params: OptimalSwapPathParams) => Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
+    validateSwapRequest: (request: SwapRequest) => Promise<SwapEarlyValidation>;
+    validateSwapProcess: (params: ValidateSwapProcessParams) => Promise<TransactionError[]>;
+    handleSwapProcess: (params: SwapSubmitParams) => Promise<SwapSubmitStepData>;
+    handleSubmitStep: (params: SwapSubmitParams) => Promise<SwapSubmitStepData>;
+    isReady?: boolean;
+    init?: () => Promise<void>;
+}
+export interface SwapBaseHandlerInitParams {
+    providerSlug: string;
+    providerName: string;
+    chainService: ChainService;
+    balanceService: BalanceService;
+}
+export declare class SwapBaseHandler {
+    private readonly providerSlug;
+    private readonly providerName;
+    chainService: ChainService;
+    balanceService: BalanceService;
+    constructor({ balanceService, chainService, providerName, providerSlug }: SwapBaseHandlerInitParams);
+    generateOptimalProcess(params: OptimalSwapPathParams, genStepFuncList: GenSwapStepFunc[]): Promise<OptimalSwapPath>;
+    validateXcmStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
+    validateTokenApproveStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
+    validateSetFeeTokenStep(params: ValidateSwapProcessParams, stepIndex: number): Promise<TransactionError[]>;
+    validateSwapStep(params: ValidateSwapProcessParams, isXcmOk: boolean, stepIndex: number): Promise<TransactionError[]>;
+    get name(): string;
+    get slug(): string;
+    get providerInfo(): SwapProvider;
+}

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

@@ -0,0 +1,162 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
+import { _getAssetDecimals, _getTokenMinAmount, _isChainEvmCompatible, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { DEFAULT_SWAP_FIRST_STEP, getSwapAlternativeAsset, MOCK_SWAP_FEE } from '@subwallet/extension-base/services/swap-service/utils';
+import { SwapErrorType, SwapFeeType } from '@subwallet/extension-base/types/swap';
+import { formatNumber } from '@subwallet/extension-base/utils';
+import BigNumber from 'bignumber.js';
+import { t } from 'i18next';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export class SwapBaseHandler {
+  constructor({
+    balanceService,
+    chainService,
+    providerName,
+    providerSlug
+  }) {
+    this.providerName = providerName;
+    this.providerSlug = providerSlug;
+    this.chainService = chainService;
+    this.balanceService = balanceService;
+  }
+
+  // public abstract getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
+  async generateOptimalProcess(params, genStepFuncList) {
+    const result = {
+      totalFee: [MOCK_SWAP_FEE],
+      steps: [DEFAULT_SWAP_FIRST_STEP]
+    };
+    try {
+      for (const genStepFunc of genStepFuncList) {
+        const step = await genStepFunc.bind(this, params)();
+        if (step) {
+          result.steps.push({
+            id: result.steps.length,
+            ...step[0]
+          });
+          result.totalFee.push(step[1]);
+        }
+      }
+      return result;
+    } catch (e) {
+      return result;
+    }
+  }
+  async validateXcmStep(params, stepIndex) {
+    const bnAmount = new BigNumber(params.selectedQuote.fromAmount);
+    const swapPair = params.selectedQuote.pair;
+    const alternativeAssetSlug = getSwapAlternativeAsset(swapPair);
+    if (!alternativeAssetSlug) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
+    const fromAsset = this.chainService.getAssetBySlug(swapPair.from);
+    const [alternativeAssetBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, alternativeAsset.originChain, alternativeAssetSlug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
+    const bnAlternativeAssetBalance = new BigNumber(alternativeAssetBalance.value);
+    const bnFromAssetBalance = new BigNumber(fromAssetBalance.value);
+    const xcmFeeComponent = params.process.totalFee[stepIndex].feeComponent[0]; // todo: can do better than indexing
+    const xcmFee = new BigNumber(xcmFeeComponent.amount || '0');
+    let xcmAmount = bnAmount.minus(bnFromAssetBalance);
+    if (_isNativeToken(alternativeAsset)) {
+      xcmAmount = xcmAmount.plus(xcmFee);
+    }
+    const alternativeTokenMinAmount = new BigNumber(alternativeAsset.minAmount || '0');
+    if (!bnAlternativeAssetBalance.minus(xcmAmount).gte(alternativeTokenMinAmount)) {
+      const maxBn = bnFromAssetBalance.plus(new BigNumber(alternativeAssetBalance.value)).minus(xcmFee).minus(alternativeTokenMinAmount);
+      const maxValue = formatNumber(maxBn.toString(), fromAsset.decimals || 0);
+      const altInputTokenInfo = this.chainService.getAssetBySlug(alternativeAssetSlug);
+      const symbol = altInputTokenInfo.symbol;
+      const alternativeChain = this.chainService.getChainInfoByKey(altInputTokenInfo.originChain);
+      const chain = this.chainService.getChainInfoByKey(fromAsset.originChain);
+      const inputNetworkName = chain.name;
+      const altNetworkName = alternativeChain.name;
+      const currentValue = formatNumber(bnFromAssetBalance.toString(), fromAsset.decimals || 0);
+      const bnMaxXCM = new BigNumber(alternativeAssetBalance.value).minus(xcmFee).minus(alternativeTokenMinAmount);
+      const maxXCMValue = formatNumber(bnMaxXCM.toString(), fromAsset.decimals || 0);
+      if (maxBn.lte(0) || bnFromAssetBalance.lte(0) || bnMaxXCM.lte(0)) {
+        return [new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, t(`Insufficient balance. Deposit ${fromAsset.symbol} and try again.`))];
+      }
+      return [new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, t('You can only enter a maximum of {{maxValue}} {{symbol}}, which is {{currentValue}} {{symbol}} ({{inputNetworkName}}) and {{maxXCMValue}} {{symbol}} ({{altNetworkName}}). Lower your amount and try again.', {
+        replace: {
+          symbol,
+          maxValue,
+          inputNetworkName,
+          altNetworkName,
+          currentValue,
+          maxXCMValue
+        }
+      }))];
+    }
+    return [];
+  }
+  async validateTokenApproveStep(params, stepIndex) {
+    return Promise.resolve([]);
+  }
+  async validateSetFeeTokenStep(params, stepIndex) {
+    return Promise.resolve([]);
+  }
+  async validateSwapStep(params, isXcmOk, stepIndex) {
+    if (!params.selectedQuote) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const selectedQuote = params.selectedQuote;
+    const currentTimestamp = +Date.now();
+    if (selectedQuote.aliveUntil <= currentTimestamp) {
+      return Promise.resolve([new TransactionError(SwapErrorType.QUOTE_TIMEOUT)]);
+    }
+    const bnAmount = new BigNumber(params.selectedQuote.fromAmount);
+    const fromAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+    const stepFee = params.process.totalFee[stepIndex].feeComponent;
+    const networkFee = stepFee.find(fee => fee.feeType === SwapFeeType.NETWORK_FEE);
+    if (!networkFee) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const feeTokenInfo = this.chainService.getAssetBySlug(networkFee.tokenSlug);
+    const feeTokenChain = this.chainService.getChainInfoByKey(feeTokenInfo.originChain);
+    const [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
+    const bnFeeTokenBalance = new BigNumber(feeTokenBalance.value);
+    const bnFromAssetBalance = new BigNumber(fromAssetBalance.value);
+    if (bnFeeTokenBalance.lte(new BigNumber(networkFee.amount))) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeTokenInfo.symbol} (${feeTokenChain.name}) to pay transaction fee`)]);
+    }
+    if (params.selectedQuote.minSwap) {
+      const minProtocolSwap = new BigNumber(params.selectedQuote.minSwap);
+      if (!isXcmOk && bnFromAssetBalance.lte(minProtocolSwap)) {
+        const parsedMinSwapValue = formatNumber(minProtocolSwap, _getAssetDecimals(fromAsset));
+        return Promise.resolve([new TransactionError(SwapErrorType.SWAP_NOT_ENOUGH_BALANCE, `Insufficient balance. You need more than ${parsedMinSwapValue} ${fromAsset.symbol} to start swapping. Deposit ${fromAsset.symbol} and try again.`)]); // todo: min swap or amount?
+      }
+    }
+
+    const bnSrcAssetMinAmount = new BigNumber(_getTokenMinAmount(fromAsset));
+    const bnMaxBalanceSwap = bnFromAssetBalance.minus(bnSrcAssetMinAmount);
+    if (!isXcmOk && bnAmount.gte(bnMaxBalanceSwap)) {
+      const parsedMaxBalanceSwap = formatNumber(bnMaxBalanceSwap, _getAssetDecimals(fromAsset));
+      return Promise.resolve([new TransactionError(SwapErrorType.SWAP_EXCEED_ALLOWANCE, `Amount too high. Lower your amount ${bnMaxBalanceSwap.gt(0) ? `below ${parsedMaxBalanceSwap} ${fromAsset.symbol}` : ''} and try again`)]);
+    }
+    if (params.recipient) {
+      const toAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+      const destChainInfo = this.chainService.getChainInfoByKey(toAsset.originChain);
+      const isEvmAddress = isEthereumAddress(params.recipient);
+      const isEvmDestChain = _isChainEvmCompatible(destChainInfo);
+      if (isEvmAddress && !isEvmDestChain || !isEvmAddress && isEvmDestChain) {
+        return Promise.resolve([new TransactionError(SwapErrorType.INVALID_RECIPIENT)]);
+      }
+    }
+    return Promise.resolve([]);
+  }
+  get name() {
+    return this.providerName;
+  }
+  get slug() {
+    return this.providerSlug;
+  }
+  get providerInfo() {
+    return {
+      id: this.providerSlug,
+      name: this.providerName
+    };
+  }
+}

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

@@ -0,0 +1,30 @@
+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 { BalanceService } from '@subwallet/extension-base/services/balance-service';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
+import { BaseStepDetail } from '@subwallet/extension-base/types/service-base';
+import { OptimalSwapPath, OptimalSwapPathParams, SwapEarlyValidation, SwapFeeInfo, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+export declare class ChainflipSwapHandler implements SwapBaseInterface {
+    private swapSdk;
+    private readonly isTestnet;
+    private swapBaseHandler;
+    constructor(chainService: ChainService, balanceService: BalanceService, isTestnet?: boolean);
+    get chainService(): ChainService;
+    get balanceService(): BalanceService;
+    get providerInfo(): import("@subwallet/extension-base/types/swap").SwapProvider;
+    get name(): string;
+    get slug(): string;
+    get assetMapping(): Record<string, import("@chainflip/sdk/dist/contracts-b0BB7B5m").A>;
+    get chainMapping(): Record<string, import("@chainflip/sdk/dist/contracts-b0BB7B5m").C>;
+    get intermediaryAssetSlug(): COMMON_ASSETS.USDC_ETHEREUM | COMMON_ASSETS.USDC_SEPOLIA;
+    validateSwapRequest(request: SwapRequest): Promise<SwapEarlyValidation>;
+    private parseSwapPath;
+    getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
+    validateSwapProcess(params: ValidateSwapProcessParams): Promise<TransactionError[]>;
+    handleSubmitStep(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    handleSwapProcess(params: SwapSubmitParams): Promise<SwapSubmitStepData>;
+    getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<OptimalSwapPath>;
+}

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

@@ -0,0 +1,399 @@
+// 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 { BasicTxErrorType, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { createTransferExtrinsic } from '@subwallet/extension-base/koni/api/dotsama/transfer';
+import { getERC20TransactionObject, getEVMTransactionObject } from '@subwallet/extension-base/koni/api/tokens/evm/transfer';
+import { _getAssetDecimals, _getChainNativeTokenSlug, _getContractAddressOfToken, _isNativeToken, _isSubstrateChain } 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, getChainflipEarlyValidationError, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
+import { SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
+import BigNumber from 'bignumber.js';
+var ChainflipFeeType;
+(function (ChainflipFeeType) {
+  ChainflipFeeType["INGRESS"] = "INGRESS";
+  ChainflipFeeType["NETWORK"] = "NETWORK";
+  ChainflipFeeType["EGRESS"] = "EGRESS";
+  ChainflipFeeType["LIQUIDITY"] = "LIQUIDITY";
+})(ChainflipFeeType || (ChainflipFeeType = {}));
+const INTERMEDIARY_MAINNET_ASSET_SLUG = COMMON_ASSETS.USDC_ETHEREUM;
+const INTERMEDIARY_TESTNET_ASSET_SLUG = COMMON_ASSETS.USDC_SEPOLIA;
+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, isTestnet = true) {
+    this.swapBaseHandler = new SwapBaseHandler({
+      chainService,
+      balanceService,
+      providerName: isTestnet ? 'Chainflip Testnet' : 'Chainflip',
+      providerSlug: isTestnet ? SwapProviderId.CHAIN_FLIP_TESTNET : SwapProviderId.CHAIN_FLIP_MAINNET
+    });
+    this.isTestnet = isTestnet;
+    this.swapSdk = new SwapSDK({
+      network: isTestnet ? 'perseverance' : 'mainnet'
+    });
+  }
+  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;
+  }
+  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;
+    } else {
+      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 srcChainInfo = this.chainService.getChainInfoByKey(srcChain);
+      const srcChainId = this.chainMapping[srcChain];
+      const destChainId = this.chainMapping[destChain];
+      const fromAssetId = this.assetMapping[fromAsset.slug];
+      const toAssetId = this.assetMapping[toAsset.slug];
+      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 => a.asset === fromAssetId);
+      const destAssetData = destAssets.find(a => a.asset === toAssetId);
+      if (!destAssetData || !srcAssetData || !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 = this.assetMapping[fromAsset.slug];
+    const toAssetId = this.assetMapping[toAsset.slug];
+    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:
+
+          // eslint-disable-next-line no-fallthrough
+          case ChainflipFeeType.EGRESS:
+            {
+              const tokenSlug = Object.keys(this.assetMapping).find(assetSlug => this.assetMapping[assetSlug] === fee.asset);
+              feeComponent.push({
+                tokenSlug,
+                amount: fee.amount,
+                feeType: SwapFeeType.NETWORK_FEE
+              });
+              break;
+            }
+          case ChainflipFeeType.NETWORK:
+
+          // eslint-disable-next-line no-fallthrough
+          case ChainflipFeeType.LIQUIDITY:
+            {
+              const tokenSlug = Object.keys(this.assetMapping).find(assetSlug => this.assetMapping[assetSlug] === fee.asset);
+              feeComponent.push({
+                tokenSlug,
+                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);
+    if (bnAmount.lte(0)) {
+      return [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 SwapStepType.DEFAULT:
+            return Promise.resolve([]);
+          case SwapStepType.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 === SwapStepType.XCM) {
+        isXcmOk = true;
+      }
+    }
+    return [];
+  }
+  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 chainType = _isSubstrateChain(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 fromAssetId = this.assetMapping[fromAsset.slug];
+    const toAssetId = this.assetMapping[toAsset.slug];
+    const depositAddressResponse = await this.swapSdk.requestDepositAddress({
+      srcChain: srcChainId,
+      destChain: destChainId,
+      srcAsset: fromAssetId,
+      destAsset: toAssetId,
+      destAddress: receiver,
+      amount: quote.fromAmount
+    });
+    const txData = {
+      address,
+      provider: this.providerInfo,
+      quote: params.quote,
+      slippage: params.slippage,
+      recipient,
+      depositChannelId: depositAddressResponse.depositChannelId,
+      depositAddress: depositAddressResponse.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({
+        from: address,
+        networkKey: chainInfo.slug,
+        substrateApi,
+        to: depositAddressResponse.depositAddress,
+        tokenInfo: fromAsset,
+        transferAll: false,
+        // always false, because we do not allow swapping all the balance
+        value: quote.fromAmount
+      });
+      extrinsic = submittableExtrinsic;
+    } else {
+      if (_isNativeToken(fromAsset)) {
+        const [transactionConfig] = await getEVMTransactionObject(chainInfo, address, depositAddressResponse.depositAddress, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        extrinsic = transactionConfig;
+      } else {
+        const [transactionConfig] = await getERC20TransactionObject(_getContractAddressOfToken(fromAsset), chainInfo, address, depositAddressResponse.depositAddress, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        extrinsic = transactionConfig;
+      }
+    }
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic,
+      transferNativeAmount: _isNativeToken(fromAsset) ? quote.fromAmount : '0',
+      // todo
+      extrinsicType: ExtrinsicType.SWAP,
+      chainType
+    };
+  }
+  async handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case SwapStepType.DEFAULT:
+        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+      case SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  async getSubmitStep(params) {
+    if (params.selectedQuote) {
+      const submitStep = {
+        name: 'Swap',
+        type: SwapStepType.SWAP
+      };
+      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    }
+    return Promise.resolve(undefined);
+  }
+  generateOptimalProcess(params) {
+    return this.swapBaseHandler.generateOptimalProcess(params, [this.getSubmitStep]);
+  }
+}

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

@@ -0,0 +1,36 @@
+import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+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 { SwapBaseInterface } from '@subwallet/extension-base/services/swap-service/handler/base-handler';
+import { BaseStepDetail } from '@subwallet/extension-base/types/service-base';
+import { OptimalSwapPath, OptimalSwapPathParams, SwapEarlyValidation, SwapFeeInfo, SwapQuote, SwapRequest, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types/swap';
+export declare class HydradxHandler implements SwapBaseInterface {
+    private swapBaseHandler;
+    private tradeRouter;
+    private readonly isTestnet;
+    isReady: boolean;
+    constructor(chainService: ChainService, balanceService: BalanceService, isTestnet?: boolean);
+    init(): Promise<void>;
+    get chain(): COMMON_CHAIN_SLUGS.HYDRADX | COMMON_CHAIN_SLUGS.HYDRADX_TESTNET;
+    get chainService(): ChainService;
+    get balanceService(): BalanceService;
+    get providerInfo(): import("@subwallet/extension-base/types/swap").SwapProvider;
+    get name(): string;
+    get slug(): string;
+    getXcmStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
+    getFeeOptionStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
+    getSubmitStep(params: OptimalSwapPathParams): Promise<[BaseStepDetail, SwapFeeInfo] | undefined>;
+    generateOptimalProcess(params: OptimalSwapPathParams): Promise<OptimalSwapPath>;
+    private getSwapPathErrors;
+    private parseSwapPath;
+    getSwapQuote(request: SwapRequest): Promise<SwapQuote | SwapError>;
+    handleXcmStep(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";
+}