@subwallet/extension-base 1.2.13-0 → 1.2.14-0

package/services/swap-service/handler/asset-hub/handler.js

@@ -0,0 +1,335 @@
+// 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 { BasicTxErrorType, ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { _getEarlyAssetHubValidationError, _validateBalanceToSwapOnAssetHub, _validateSwapRecipient } from '@subwallet/extension-base/core/logic-validation/swap';
+import { createXcmExtrinsic } from '@subwallet/extension-base/services/balance-service/transfer/xcm';
+import { _getChainNativeTokenSlug, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { convertSwapRate, getSwapAlternativeAsset, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
+import { CommonStepType } from '@subwallet/extension-base/types/service-base';
+import { SwapErrorType, SwapFeeType, SwapProviderId, SwapStepType } from '@subwallet/extension-base/types/swap';
+import BigN from 'bignumber.js';
+import { SwapBaseHandler } from "../base-handler.js";
+import { AssetHubRouter } from "./router.js";
+const PAH_LOW_LIQUIDITY_THRESHOLD = 0.15;
+export class AssetHubSwapHandler {
+  isReady = false;
+  constructor(chainService, balanceService, chain) {
+    const chainInfo = chainService.getChainInfoByKey(chain);
+    const providerSlug = chain === 'statemint' ? SwapProviderId.POLKADOT_ASSET_HUB : chain === 'statemine' ? SwapProviderId.KUSAMA_ASSET_HUB : SwapProviderId.ROCOCO_ASSET_HUB;
+    this.swapBaseHandler = new SwapBaseHandler({
+      balanceService,
+      chainService,
+      providerName: chainInfo.name,
+      providerSlug
+    });
+    this.providerSlug = providerSlug;
+    this.chain = chain;
+  }
+  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 init() {
+    const chainState = this.chainService.getChainStateByKey(this.chain);
+    if (!chainState.active) {
+      await this.chainService.enableChain(this.chain);
+    }
+    const substrateApi = this.chainService.getSubstrateApi(this.chain);
+    await substrateApi.api.isReady;
+    this.router = new AssetHubRouter(this.chain, this.chainService);
+    this.isReady = true;
+  }
+  async getXcmStep(params) {
+    const bnAmount = new BigN(params.request.fromAmount);
+    const fromAsset = this.chainService.getAssetBySlug(params.request.pair.from);
+    const fromAssetBalance = await this.balanceService.getTransferableBalance(params.request.address, fromAsset.originChain, fromAsset.slug);
+    const bnFromAssetBalance = new BigN(fromAssetBalance.value);
+    if (bnFromAssetBalance.gte(bnAmount)) {
+      return undefined; // enough balance, no need to xcm
+    }
+
+    const alternativeAssetSlug = getSwapAlternativeAsset(params.request.pair);
+    if (!alternativeAssetSlug) {
+      return undefined;
+    }
+    const alternativeAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
+    const alternativeAssetBalance = await this.balanceService.getTransferableBalance(params.request.address, alternativeAsset.originChain, alternativeAsset.slug);
+    const bnAlternativeAssetBalance = new BigN(alternativeAssetBalance.value);
+    if (bnAlternativeAssetBalance.lte(0)) {
+      return undefined;
+    }
+    try {
+      const alternativeChainInfo = this.chainService.getChainInfoByKey(alternativeAsset.originChain);
+      const step = {
+        metadata: {
+          sendingValue: bnAmount.toString(),
+          originTokenInfo: alternativeAsset,
+          destinationTokenInfo: fromAsset
+        },
+        name: `Transfer ${alternativeAsset.symbol} from ${alternativeChainInfo.name}`,
+        type: CommonStepType.XCM
+      };
+      const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
+      const xcmTransfer = await createXcmExtrinsic({
+        originTokenInfo: alternativeAsset,
+        destinationTokenInfo: fromAsset,
+        sendingValue: bnAmount.toString(),
+        recipient: params.request.address,
+        chainInfoMap: this.chainService.getChainInfoMap(),
+        substrateApi: xcmOriginSubstrateApi
+      });
+      const _xcmFeeInfo = await xcmTransfer.paymentInfo(params.request.address);
+      const xcmFeeInfo = _xcmFeeInfo.toPrimitive();
+      const fee = {
+        feeComponent: [{
+          feeType: SwapFeeType.NETWORK_FEE,
+          amount: Math.round(xcmFeeInfo.partialFee * 1.2).toString(),
+          tokenSlug: _getChainNativeTokenSlug(alternativeChainInfo)
+        }],
+        defaultFeeToken: _getChainNativeTokenSlug(alternativeChainInfo),
+        feeOptions: [_getChainNativeTokenSlug(alternativeChainInfo)]
+      };
+      return [step, fee];
+    } catch (e) {
+      return undefined;
+    }
+  }
+  async getSubmitStep(params) {
+    if (params.selectedQuote) {
+      const submitStep = {
+        name: 'Swap',
+        type: SwapStepType.SWAP
+      };
+      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    }
+    return Promise.resolve(undefined);
+  }
+  generateOptimalProcess(params) {
+    return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep, this.getSubmitStep]);
+  }
+  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.router) {
+      return new SwapError(SwapErrorType.UNKNOWN);
+    }
+    const earlyValidation = await this.validateSwapRequest(request);
+    if (earlyValidation.error) {
+      const metadata = earlyValidation.metadata;
+      return _getEarlyAssetHubValidationError(earlyValidation.error, metadata);
+    }
+    try {
+      const paths = this.router.buildPath(request.pair);
+      const amountOut = earlyValidation.metadata.toAmount;
+      const toAmount = new BigN(amountOut);
+      const minReceive = toAmount.times(1 - request.slippage).integerValue(BigN.ROUND_DOWN);
+      const extrinsic = await this.router.buildSwapExtrinsic(paths, request.address, request.fromAmount, minReceive.toString());
+      const paymentInfo = await extrinsic.paymentInfo(request.address);
+      const networkFee = {
+        tokenSlug: fromChainNativeTokenSlug,
+        amount: paymentInfo.partialFee.toString(),
+        feeType: SwapFeeType.NETWORK_FEE
+      };
+      const feeTokenOptions = [fromChainNativeTokenSlug];
+      const selectedFeeToken = fromChainNativeTokenSlug;
+      const priceImpactPct = earlyValidation.metadata.priceImpactPct || '0';
+      return {
+        pair: request.pair,
+        fromAmount: request.fromAmount,
+        toAmount: toAmount.toString(),
+        rate: convertSwapRate(earlyValidation.metadata.quoteRate, fromAsset, toAsset),
+        provider: this.providerInfo,
+        aliveUntil: +Date.now() + (SWAP_QUOTE_TIMEOUT_MAP[this.slug] || SWAP_QUOTE_TIMEOUT_MAP.default),
+        feeInfo: {
+          feeComponent: [networkFee],
+          defaultFeeToken: fromChainNativeTokenSlug,
+          feeOptions: feeTokenOptions,
+          // TODO: enable fee options
+          selectedFeeToken
+        },
+        isLowLiquidity: Math.abs(parseFloat(priceImpactPct)) >= PAH_LOW_LIQUIDITY_THRESHOLD,
+        route: {
+          path: paths.map(asset => asset.slug)
+        }
+      };
+    } catch (e) {
+      return new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
+    }
+  }
+  async handleXcmStep(params) {
+    const pair = params.quote.pair;
+    const alternativeAssetSlug = getSwapAlternativeAsset(pair);
+    const originAsset = this.chainService.getAssetBySlug(alternativeAssetSlug);
+    const destinationAsset = this.chainService.getAssetBySlug(pair.from);
+    const substrateApi = this.chainService.getSubstrateApi(originAsset.originChain);
+    const chainApi = await substrateApi.isReady;
+    const destinationAssetBalance = await this.balanceService.getTransferableBalance(params.address, destinationAsset.originChain, destinationAsset.slug);
+    const xcmFee = params.process.totalFee[params.currentStep];
+    const bnAmount = new BigN(params.quote.fromAmount);
+    const bnDestinationAssetBalance = new BigN(destinationAssetBalance.value);
+    let bnTotalAmount = bnAmount.minus(bnDestinationAssetBalance);
+    if (_isNativeToken(originAsset)) {
+      const bnXcmFee = new BigN(xcmFee.feeComponent[0].amount); // xcm fee is paid in native token but swap token is not always native token
+
+      bnTotalAmount = bnTotalAmount.plus(bnXcmFee);
+    }
+    const xcmTransfer = await createXcmExtrinsic({
+      originTokenInfo: originAsset,
+      destinationTokenInfo: destinationAsset,
+      sendingValue: bnTotalAmount.toString(),
+      recipient: params.address,
+      chainInfoMap: this.chainService.getChainInfoMap(),
+      substrateApi: chainApi
+    });
+    const xcmData = {
+      originNetworkKey: originAsset.originChain,
+      destinationNetworkKey: destinationAsset.originChain,
+      from: params.address,
+      to: params.address,
+      value: bnTotalAmount.toString(),
+      tokenSlug: originAsset.slug,
+      showExtraWarning: true
+    };
+    return {
+      txChain: originAsset.originChain,
+      extrinsic: xcmTransfer,
+      transferNativeAmount: _isNativeToken(originAsset) ? bnTotalAmount.toString() : '0',
+      extrinsicType: ExtrinsicType.TRANSFER_XCM,
+      chainType: ChainType.SUBSTRATE,
+      txData: xcmData
+    };
+  }
+  async handleSubmitStep(params) {
+    var _this$router;
+    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
+    const txData = {
+      provider: this.providerInfo,
+      quote: params.quote,
+      address: params.address,
+      slippage: params.slippage,
+      process: params.process
+    };
+    const paths = params.quote.route.path.map(slug => this.chainService.getAssetBySlug(slug));
+    const {
+      fromAmount,
+      toAmount
+    } = params.quote;
+    const minReceive = new BigN(1 - params.slippage).times(toAmount).integerValue(BigN.ROUND_DOWN);
+    const extrinsic = await ((_this$router = this.router) === null || _this$router === void 0 ? void 0 : _this$router.buildSwapExtrinsic(paths, params.address, fromAmount, minReceive.toString()));
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic,
+      transferNativeAmount: _isNativeToken(fromAsset) ? params.quote.fromAmount : '0',
+      // todo
+      extrinsicType: ExtrinsicType.SWAP,
+      chainType: ChainType.SUBSTRATE
+    };
+  }
+  handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case CommonStepType.XCM:
+        return this.handleXcmStep(params);
+      case SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+    }
+  }
+  async validateSwapStep(params, isXcmOk, stepIndex) {
+    // check swap quote timestamp
+    // check balance to pay transaction fee
+    // check balance against spending amount
+    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 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 fromAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+    const feeTokenInfo = this.chainService.getAssetBySlug(networkFee.tokenSlug);
+    const feeTokenChain = this.chainService.getChainInfoByKey(feeTokenInfo.originChain);
+    const {
+      fromAmount,
+      minSwap
+    } = params.selectedQuote;
+    const [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTransferableBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTransferableBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
+    const balanceError = _validateBalanceToSwapOnAssetHub(fromAsset, feeTokenInfo, feeTokenChain, networkFee.amount, fromAssetBalance.value, feeTokenBalance.value, fromAmount, isXcmOk, minSwap);
+    if (balanceError) {
+      return Promise.resolve([balanceError]);
+    }
+    if (!params.recipient) {
+      return Promise.resolve([]);
+    }
+    const toAsset = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const toAssetChain = this.chainService.getChainInfoByKey(toAsset.originChain);
+    const recipientError = _validateSwapRecipient(toAssetChain, params.recipient);
+    if (recipientError) {
+      return Promise.resolve([recipientError]);
+    }
+    return Promise.resolve([]);
+  }
+  async validateSwapProcess(params) {
+    const amount = params.selectedQuote.fromAmount;
+    const bnAmount = new BigN(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 CommonStepType.DEFAULT:
+            return Promise.resolve([]);
+          case CommonStepType.XCM:
+            return this.swapBaseHandler.validateXcmStep(params, index);
+          case SwapStepType.SWAP:
+            return this.validateSwapStep(params, isXcmOk, index);
+          default:
+            return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+        }
+      };
+      const errors = await getErrors();
+      if (errors.length) {
+        return errors;
+      } else if (step.type === CommonStepType.XCM) {
+        isXcmOk = true;
+      }
+    }
+    return [];
+  }
+  validateSwapRequest(request) {
+    if (!this.isReady || !this.router) {
+      throw new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
+    }
+    return this.router.earlyValidateSwapValidation(request);
+  }
+}

package/services/swap-service/handler/asset-hub/index.d.ts

@@ -0,0 +1 @@
+export { AssetHubSwapHandler } from './handler';

package/services/swap-service/handler/asset-hub/index.js

@@ -0,0 +1,4 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export { AssetHubSwapHandler } from "./handler.js";

package/services/swap-service/handler/asset-hub/router.d.ts

@@ -0,0 +1,16 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { AssetHubSwapEarlyValidation, SwapPair, SwapRequest } from '@subwallet/extension-base/types/swap';
+import { SubmittableExtrinsic } from '@polkadot/api/types';
+export declare class AssetHubRouter {
+    private readonly chain;
+    readonly chainService: ChainService;
+    constructor(chain: string, chainService: ChainService);
+    get substrateApi(): _SubstrateApi;
+    get nativeToken(): _ChainAsset;
+    buildPath(pair: SwapPair): Array<_ChainAsset>;
+    earlyValidateSwapValidation(request: SwapRequest): Promise<AssetHubSwapEarlyValidation>;
+    estimateAmountOut(pair: SwapPair, amountIn: string): Promise<string>;
+    buildSwapExtrinsic(path: Array<_ChainAsset>, recipient: string, amountIn: string, amountOutMin: string): Promise<SubmittableExtrinsic<'promise'>>;
+}

package/services/swap-service/handler/asset-hub/router.js

@@ -0,0 +1,85 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { _getTokenMinAmount } from '@subwallet/extension-base/services/chain-service/utils';
+import { buildSwapExtrinsic, checkLiquidityForPath, checkMinAmountForPath, estimatePriceImpactPct, estimateRateAfter, estimateRateForPath, estimateTokensForPath, getReserveForPath } from '@subwallet/extension-base/services/swap-service/handler/asset-hub/utils';
+import { SwapErrorType } from '@subwallet/extension-base/types/swap';
+import BigN from 'bignumber.js';
+export class AssetHubRouter {
+  constructor(chain, chainService) {
+    this.chain = chain;
+    this.chainService = chainService;
+  }
+  get substrateApi() {
+    return this.chainService.getSubstrateApi(this.chain);
+  }
+  get nativeToken() {
+    return this.chainService.getNativeTokenInfo(this.chain);
+  }
+  buildPath(pair) {
+    // const nativeToken = this.nativeToken;
+    // const nativeTokenSlug = nativeToken.slug;
+
+    const assetFrom = this.chainService.getAssetBySlug(pair.from);
+    const assetTo = this.chainService.getAssetBySlug(pair.to);
+    return [assetFrom, assetTo];
+    // if (pair.from === nativeTokenSlug || pair.to === nativeTokenSlug) {
+    //   return [assetFrom, assetTo];
+    // } else {
+    //   return [assetFrom, nativeToken, assetTo];
+    // }
+  }
+
+  async earlyValidateSwapValidation(request) {
+    const substrateApi = await this.substrateApi.isReady;
+    const paths = this.buildPath(request.pair);
+    const api = await substrateApi.api.isReady;
+    const amount = request.fromAmount;
+    const reserves = await getReserveForPath(api, paths);
+    const amounts = estimateTokensForPath(amount, reserves);
+    const marketRate = estimateRateForPath(reserves);
+    const marketRateAfter = estimateRateAfter(amount, reserves);
+    const priceImpactPct = estimatePriceImpactPct(marketRate, marketRateAfter);
+    const errors = [];
+
+    // Check liquidity
+    const liquidityError = checkLiquidityForPath(amounts, reserves);
+    if (liquidityError) {
+      errors.push(liquidityError);
+    }
+
+    // Check amount token in pool after swap
+    const minAmounts = paths.map(asset => _getTokenMinAmount(asset));
+    const minAmountAfterSwapError = checkMinAmountForPath(reserves, amounts, minAmounts);
+    if (minAmountAfterSwapError) {
+      errors.push(minAmountAfterSwapError);
+    }
+    const bnAmount = new BigN(request.fromAmount);
+    if (bnAmount.lte(0)) {
+      errors.push(SwapErrorType.AMOUNT_CANNOT_BE_ZERO);
+    }
+    const metadata = {
+      chain: this.chainService.getChainInfoByKey(this.chain),
+      toAmount: amounts[amounts.length - 1],
+      quoteRate: marketRate,
+      priceImpactPct: priceImpactPct
+    };
+    return {
+      error: errors[0],
+      metadata
+    };
+  }
+  async estimateAmountOut(pair, amountIn) {
+    const substrateApi = await this.substrateApi.isReady;
+    const paths = this.buildPath(pair);
+    const api = await substrateApi.api.isReady;
+    const reserves = await getReserveForPath(api, paths);
+    const amounts = estimateTokensForPath(amountIn, reserves);
+    return amounts[amounts.length - 1];
+  }
+  async buildSwapExtrinsic(path, recipient, amountIn, amountOutMin) {
+    const substrateApi = await this.substrateApi.isReady;
+    const api = await substrateApi.api.isReady;
+    return buildSwapExtrinsic(api, path, recipient, amountIn, amountOutMin);
+  }
+}

package/services/swap-service/handler/asset-hub/utils.d.ts

@@ -0,0 +1,18 @@
+import { _ChainAsset } from '@subwallet/chain-list/types';
+import { SwapErrorType } from '@subwallet/extension-base/types/swap';
+import { ApiPromise } from '@polkadot/api';
+import { SubmittableExtrinsic } from '@polkadot/api/types';
+export declare const _getPoolInfo: (api: ApiPromise, asset1: _ChainAsset, asset2: _ChainAsset) => Promise<[string, string]>;
+export declare const getReserveForPool: (api: ApiPromise, asset1: _ChainAsset, asset2: _ChainAsset) => Promise<[string, string]>;
+export declare const getReserveForPath: (api: ApiPromise, paths: _ChainAsset[]) => Promise<Array<[string, string]>>;
+export declare const estimateTokensForPool: (amount: string, reserves: [string, string]) => string;
+export declare const estimateTokensForPath: (amount: string, reserves: Array<[string, string]>) => string[];
+export declare const estimateRateForPath: (reserves: Array<[string, string]>) => string;
+export declare const estimateActualRate: (amount: string, reserves: Array<[string, string]>) => string;
+export declare const estimateRateAfter: (amount: string, reserves: Array<[string, string]>) => string;
+export declare const estimatePriceImpactPct: (marketRate: string, marketRateAfter: string) => string;
+export declare const checkLiquidityForPool: (amount: string, reserve1: string, reserve2: string) => SwapErrorType | undefined;
+export declare const checkLiquidityForPath: (amounts: string[], reserves: Array<[string, string]>) => SwapErrorType | undefined;
+export declare const checkMinAmountForPool: (reserve1: string, reserve2: string, amount1: string, amount2: string, minAmount1: string, minAmount2: string) => SwapErrorType | undefined;
+export declare const checkMinAmountForPath: (reserves: Array<[string, string]>, amounts: string[], minAmounts: string[]) => SwapErrorType | undefined;
+export declare const buildSwapExtrinsic: (api: ApiPromise, paths: _ChainAsset[], recipient: string, amountIn: string, amountOutMin: string, keepAlive?: boolean) => SubmittableExtrinsic<'promise'>;

package/services/swap-service/handler/asset-hub/utils.js

@@ -0,0 +1,133 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { _getXcmAssetMultilocation } from '@subwallet/extension-base/services/chain-service/utils';
+import { SwapErrorType } from '@subwallet/extension-base/types/swap';
+import BigN from 'bignumber.js';
+export const _getPoolInfo = async (api, asset1, asset2) => {
+  const assetLocation1 = _getXcmAssetMultilocation(asset1);
+  const assetLocation2 = _getXcmAssetMultilocation(asset2);
+  const rs = await api.call.assetConversionApi.getReserves(assetLocation1, assetLocation2);
+  if (!rs) {
+    return ['0', '0'];
+  }
+  const [balanceAsset1, balanceAsset2] = rs.unwrapOrDefault();
+  return [balanceAsset1.toString(), balanceAsset2.toString()];
+};
+export const getReserveForPool = async (api, asset1, asset2) => {
+  let [balanceAsset1, balanceAsset2] = await _getPoolInfo(api, asset1, asset2);
+  if (balanceAsset1 !== '0' && balanceAsset2 !== '0') {
+    return [balanceAsset1, balanceAsset2];
+  } else {
+    [balanceAsset2, balanceAsset1] = await _getPoolInfo(api, asset2, asset1);
+    return [balanceAsset1, balanceAsset2];
+  }
+};
+export const getReserveForPath = async (api, paths) => {
+  const pairs = [];
+  for (let i = 0; i < paths.length - 1; i++) {
+    const asset1 = paths[i];
+    const asset2 = paths[i + 1];
+    pairs.push([asset1, asset2]);
+  }
+  return await Promise.all(pairs.map(async ([asset1, asset2]) => getReserveForPool(api, asset1, asset2)));
+};
+export const estimateTokensForPool = (amount, reserves) => {
+  if (amount === '0') {
+    return '0';
+  }
+  return new BigN(amount).times(reserves[1]).div(reserves[0]).integerValue(BigN.ROUND_DOWN).toString();
+};
+export const estimateTokensForPath = (amount, reserves) => {
+  const result = [amount];
+  for (let i = 0; i < reserves.length; i++) {
+    const reserve = reserves[i];
+    const currentAmount = result[i];
+    const nextAmount = estimateTokensForPool(currentAmount, reserve);
+    result.push(nextAmount);
+  }
+  return result;
+};
+export const estimateRateForPath = reserves => {
+  let result = new BigN(1);
+  for (const reserve of reserves) {
+    result = result.times(reserve[0]).div(reserve[1]);
+  }
+  return result.toString();
+};
+export const estimateActualRate = (amount, reserves) => {
+  let result = new BigN(1);
+  const m = new BigN(amount);
+
+  // Currently support for direct path swap only
+  for (const reserve of reserves) {
+    const x = new BigN(reserve[0]);
+    const y = new BigN(reserve[1]);
+    result = result.times(x.plus(m)).div(y);
+  }
+  return result.toString();
+};
+export const estimateRateAfter = (amount, reserves) => {
+  const m = new BigN(amount);
+  const reserve = reserves[0];
+  const x = new BigN(reserve[0]);
+  const y = new BigN(reserve[1]);
+  const n = y.multipliedBy(m).div(x.plus(m));
+  const result = x.plus(m).div(y.minus(n));
+  return result.toString();
+};
+export const estimatePriceImpactPct = (marketRate, marketRateAfter) => {
+  const bnMarketRate = new BigN(marketRate);
+  const bnActualRate = new BigN(marketRateAfter);
+  return new BigN(1).minus(bnMarketRate.div(bnActualRate)).multipliedBy(100).toString();
+};
+export const checkLiquidityForPool = (amount, reserve1, reserve2) => {
+  if (new BigN(reserve1).eq('0') || new BigN(reserve2).eq('0')) {
+    return SwapErrorType.ASSET_NOT_SUPPORTED;
+  } else if (new BigN(reserve1).lt(amount)) {
+    return SwapErrorType.NOT_ENOUGH_LIQUIDITY;
+  }
+  return undefined;
+};
+export const checkLiquidityForPath = (amounts, reserves) => {
+  for (let i = 0; i < reserves.length; i++) {
+    const amount = amounts[i];
+    const [reserve1, reserve2] = reserves[i];
+    const error = checkLiquidityForPool(amount, reserve1, reserve2);
+    if (error) {
+      return error;
+    }
+  }
+  return undefined;
+};
+
+// Swap from asset1 to asset2
+export const checkMinAmountForPool = (reserve1, reserve2, amount1, amount2, minAmount1, minAmount2) => {
+  const newReserve1 = new BigN(reserve1).plus(amount1);
+  const newReserve2 = new BigN(reserve2).minus(amount2);
+  if (newReserve1.lt(minAmount1) || newReserve2.lt(minAmount2)) {
+    return SwapErrorType.MAKE_POOL_NOT_ENOUGH_EXISTENTIAL_DEPOSIT;
+  }
+  return undefined;
+};
+export const checkMinAmountForPath = (reserves, amounts, minAmounts) => {
+  for (let i = 0; i < reserves.length; i++) {
+    const [amount1, amount2] = amounts.slice(i, 2);
+    const [minAmount1, minAmount2] = minAmounts.slice(i, 2);
+    const [reserve1, reserve2] = reserves[i];
+    const error = checkMinAmountForPool(reserve1, reserve2, amount1, amount2, minAmount1, minAmount2);
+    if (error) {
+      return error;
+    }
+  }
+  return undefined;
+};
+
+// Build extrinsic for swap
+export const buildSwapExtrinsic = (api, paths, recipient, amountIn, amountOutMin, keepAlive = true) => {
+  const pathsInfo = paths.map(asset => {
+    const multilocation = _getXcmAssetMultilocation(asset);
+    return api.createType('MultiLocation', multilocation).toU8a();
+  });
+  return api.tx.assetConversion.swapExactTokensForTokens(pathsInfo, amountIn, amountOutMin, recipient, keepAlive);
+};

package/services/swap-service/index.js

@@ -5,6 +5,7 @@ import { SwapError } from '@subwallet/extension-base/background/errors/SwapError
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
+import { AssetHubSwapHandler } from '@subwallet/extension-base/services/swap-service/handler/asset-hub';
 import { ChainflipSwapHandler } from '@subwallet/extension-base/services/swap-service/handler/chainflip-handler';
 import { HydradxHandler } from '@subwallet/extension-base/services/swap-service/handler/hydradx-handler';
 import { _PROVIDER_TO_SUPPORTED_PAIR_MAP, getSwapAltToken, SWAP_QUOTE_TIMEOUT_MAP } from '@subwallet/extension-base/services/swap-service/utils';
@@ -91,7 +92,6 @@ export class SwapService {
       request,
       selectedQuote: swapQuoteResponse.optimalQuote
     });
-    console.log('optimalProcess', optimalProcess);
     return {
       process: optimalProcess,
       quote: swapQuoteResponse
@@ -141,6 +141,15 @@ export class SwapService {
         case SwapProviderId.HYDRADX_MAINNET:
           this.handlers[providerId] = new HydradxHandler(this.chainService, this.state.balanceService, false);
           break;
+        case SwapProviderId.POLKADOT_ASSET_HUB:
+          this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, 'statemint');
+          break;
+        case SwapProviderId.KUSAMA_ASSET_HUB:
+          this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, 'statemine');
+          break;
+        case SwapProviderId.ROCOCO_ASSET_HUB:
+          this.handlers[providerId] = new AssetHubSwapHandler(this.chainService, this.state.balanceService, 'rococo_assethub');
+          break;
         default:
           throw new Error('Unsupported provider');
       }

package/services/swap-service/utils.d.ts

@@ -12,3 +12,4 @@ export declare const _PROVIDER_TO_SUPPORTED_PAIR_MAP: Record<string, string[]>;
 export declare function getSwapAlternativeAsset(swapPair: SwapPair): string | undefined;
 export declare function getSwapAltToken(chainAsset: _ChainAsset): string | undefined;
 export declare function calculateSwapRate(fromAmount: string, toAmount: string, fromAsset: _ChainAsset, toAsset: _ChainAsset): number;
+export declare function convertSwapRate(rate: string, fromAsset: _ChainAsset, toAsset: _ChainAsset): number;

package/services/swap-service/utils.js

@@ -36,7 +36,10 @@ export const _PROVIDER_TO_SUPPORTED_PAIR_MAP = {
   [SwapProviderId.HYDRADX_MAINNET]: [COMMON_CHAIN_SLUGS.HYDRADX],
   [SwapProviderId.HYDRADX_TESTNET]: [COMMON_CHAIN_SLUGS.HYDRADX_TESTNET],
   [SwapProviderId.CHAIN_FLIP_MAINNET]: [COMMON_CHAIN_SLUGS.POLKADOT, COMMON_CHAIN_SLUGS.ETHEREUM],
-  [SwapProviderId.CHAIN_FLIP_TESTNET]: [COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT, COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA]
+  [SwapProviderId.CHAIN_FLIP_TESTNET]: [COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT, COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA],
+  [SwapProviderId.POLKADOT_ASSET_HUB]: [COMMON_CHAIN_SLUGS.POLKADOT_ASSET_HUB],
+  [SwapProviderId.KUSAMA_ASSET_HUB]: [COMMON_CHAIN_SLUGS.KUSAMA_ASSET_HUB],
+  [SwapProviderId.ROCOCO_ASSET_HUB]: [COMMON_CHAIN_SLUGS.ROCOCO_ASSET_HUB]
 };
 export function getSwapAlternativeAsset(swapPair) {
   var _swapPair$metadata;
@@ -52,4 +55,9 @@ export function calculateSwapRate(fromAmount, toAmount, fromAsset, toAsset) {
   const decimalDiff = _getAssetDecimals(toAsset) - _getAssetDecimals(fromAsset);
   const bnRate = bnFromAmount.div(bnToAmount);
   return 1 / bnRate.times(10 ** decimalDiff).toNumber();
+}
+export function convertSwapRate(rate, fromAsset, toAsset) {
+  const decimalDiff = _getAssetDecimals(toAsset) - _getAssetDecimals(fromAsset);
+  const bnRate = new BigN(rate);
+  return bnRate.times(10 ** decimalDiff).pow(-1).toNumber();
 }