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

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

@@ -0,0 +1,343 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AssetHubSwapHandler = void 0;
+var _SwapError = require("@subwallet/extension-base/background/errors/SwapError");
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _swap = require("@subwallet/extension-base/core/logic-validation/swap");
+var _xcm = require("@subwallet/extension-base/services/balance-service/transfer/xcm");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
+var _serviceBase = require("@subwallet/extension-base/types/service-base");
+var _swap2 = require("@subwallet/extension-base/types/swap");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _baseHandler = require("../base-handler");
+var _router = require("./router");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const PAH_LOW_LIQUIDITY_THRESHOLD = 0.15;
+class AssetHubSwapHandler {
+  isReady = false;
+  constructor(chainService, balanceService, chain) {
+    const chainInfo = chainService.getChainInfoByKey(chain);
+    const providerSlug = chain === 'statemint' ? _swap2.SwapProviderId.POLKADOT_ASSET_HUB : chain === 'statemine' ? _swap2.SwapProviderId.KUSAMA_ASSET_HUB : _swap2.SwapProviderId.ROCOCO_ASSET_HUB;
+    this.swapBaseHandler = new _baseHandler.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 _router.AssetHubRouter(this.chain, this.chainService);
+    this.isReady = true;
+  }
+  async getXcmStep(params) {
+    const bnAmount = new _bignumber.default(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 _bignumber.default(fromAssetBalance.value);
+    if (bnFromAssetBalance.gte(bnAmount)) {
+      return undefined; // enough balance, no need to xcm
+    }
+
+    const alternativeAssetSlug = (0, _utils2.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 _bignumber.default(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: _serviceBase.CommonStepType.XCM
+      };
+      const xcmOriginSubstrateApi = await this.chainService.getSubstrateApi(alternativeAsset.originChain).isReady;
+      const xcmTransfer = await (0, _xcm.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: _swap2.SwapFeeType.NETWORK_FEE,
+          amount: Math.round(xcmFeeInfo.partialFee * 1.2).toString(),
+          tokenSlug: (0, _utils._getChainNativeTokenSlug)(alternativeChainInfo)
+        }],
+        defaultFeeToken: (0, _utils._getChainNativeTokenSlug)(alternativeChainInfo),
+        feeOptions: [(0, _utils._getChainNativeTokenSlug)(alternativeChainInfo)]
+      };
+      return [step, fee];
+    } catch (e) {
+      return undefined;
+    }
+  }
+  async getSubmitStep(params) {
+    if (params.selectedQuote) {
+      const submitStep = {
+        name: 'Swap',
+        type: _swap2.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 = (0, _utils._getChainNativeTokenSlug)(fromChain);
+    if (!this.isReady || !this.router) {
+      return new _SwapError.SwapError(_swap2.SwapErrorType.UNKNOWN);
+    }
+    const earlyValidation = await this.validateSwapRequest(request);
+    if (earlyValidation.error) {
+      const metadata = earlyValidation.metadata;
+      return (0, _swap._getEarlyAssetHubValidationError)(earlyValidation.error, metadata);
+    }
+    try {
+      const paths = this.router.buildPath(request.pair);
+      const amountOut = earlyValidation.metadata.toAmount;
+      const toAmount = new _bignumber.default(amountOut);
+      const minReceive = toAmount.times(1 - request.slippage).integerValue(_bignumber.default.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: _swap2.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: (0, _utils2.convertSwapRate)(earlyValidation.metadata.quoteRate, fromAsset, toAsset),
+        provider: this.providerInfo,
+        aliveUntil: +Date.now() + (_utils2.SWAP_QUOTE_TIMEOUT_MAP[this.slug] || _utils2.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.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
+    }
+  }
+  async handleXcmStep(params) {
+    const pair = params.quote.pair;
+    const alternativeAssetSlug = (0, _utils2.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 _bignumber.default(params.quote.fromAmount);
+    const bnDestinationAssetBalance = new _bignumber.default(destinationAssetBalance.value);
+    let bnTotalAmount = bnAmount.minus(bnDestinationAssetBalance);
+    if ((0, _utils._isNativeToken)(originAsset)) {
+      const bnXcmFee = new _bignumber.default(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 (0, _xcm.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: (0, _utils._isNativeToken)(originAsset) ? bnTotalAmount.toString() : '0',
+      extrinsicType: _KoniTypes.ExtrinsicType.TRANSFER_XCM,
+      chainType: _KoniTypes.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 _bignumber.default(1 - params.slippage).times(toAmount).integerValue(_bignumber.default.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: (0, _utils._isNativeToken)(fromAsset) ? params.quote.fromAmount : '0',
+      // todo
+      extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
+      chainType: _KoniTypes.ChainType.SUBSTRATE
+    };
+  }
+  handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case _serviceBase.CommonStepType.XCM:
+        return this.handleXcmStep(params);
+      case _swap2.SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const selectedQuote = params.selectedQuote;
+    const currentTimestamp = +Date.now();
+    if (selectedQuote.aliveUntil <= currentTimestamp) {
+      return Promise.resolve([new _TransactionError.TransactionError(_swap2.SwapErrorType.QUOTE_TIMEOUT)]);
+    }
+    const stepFee = params.process.totalFee[stepIndex].feeComponent;
+    const networkFee = stepFee.find(fee => fee.feeType === _swap2.SwapFeeType.NETWORK_FEE);
+    if (!networkFee) {
+      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.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 = (0, _swap._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 = (0, _swap._validateSwapRecipient)(toAssetChain, params.recipient);
+    if (recipientError) {
+      return Promise.resolve([recipientError]);
+    }
+    return Promise.resolve([]);
+  }
+  async validateSwapProcess(params) {
+    const amount = params.selectedQuote.fromAmount;
+    const bnAmount = new _bignumber.default(amount);
+    if (bnAmount.lte(0)) {
+      return [new _TransactionError.TransactionError(_KoniTypes.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 _serviceBase.CommonStepType.DEFAULT:
+            return Promise.resolve([]);
+          case _serviceBase.CommonStepType.XCM:
+            return this.swapBaseHandler.validateXcmStep(params, index);
+          case _swap2.SwapStepType.SWAP:
+            return this.validateSwapStep(params, isXcmOk, index);
+          default:
+            return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+        }
+      };
+      const errors = await getErrors();
+      if (errors.length) {
+        return errors;
+      } else if (step.type === _serviceBase.CommonStepType.XCM) {
+        isXcmOk = true;
+      }
+    }
+    return [];
+  }
+  validateSwapRequest(request) {
+    if (!this.isReady || !this.router) {
+      throw new _SwapError.SwapError(_swap2.SwapErrorType.ERROR_FETCHING_QUOTE);
+    }
+    return this.router.earlyValidateSwapValidation(request);
+  }
+}
+exports.AssetHubSwapHandler = AssetHubSwapHandler;

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

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AssetHubSwapHandler", {
+  enumerable: true,
+  get: function () {
+    return _handler.AssetHubSwapHandler;
+  }
+});
+var _handler = require("./handler");

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

@@ -0,0 +1,93 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AssetHubRouter = void 0;
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/services/swap-service/handler/asset-hub/utils");
+var _swap = require("@subwallet/extension-base/types/swap");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+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 (0, _utils2.getReserveForPath)(api, paths);
+    const amounts = (0, _utils2.estimateTokensForPath)(amount, reserves);
+    const marketRate = (0, _utils2.estimateRateForPath)(reserves);
+    const marketRateAfter = (0, _utils2.estimateRateAfter)(amount, reserves);
+    const priceImpactPct = (0, _utils2.estimatePriceImpactPct)(marketRate, marketRateAfter);
+    const errors = [];
+
+    // Check liquidity
+    const liquidityError = (0, _utils2.checkLiquidityForPath)(amounts, reserves);
+    if (liquidityError) {
+      errors.push(liquidityError);
+    }
+
+    // Check amount token in pool after swap
+    const minAmounts = paths.map(asset => (0, _utils._getTokenMinAmount)(asset));
+    const minAmountAfterSwapError = (0, _utils2.checkMinAmountForPath)(reserves, amounts, minAmounts);
+    if (minAmountAfterSwapError) {
+      errors.push(minAmountAfterSwapError);
+    }
+    const bnAmount = new _bignumber.default(request.fromAmount);
+    if (bnAmount.lte(0)) {
+      errors.push(_swap.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 (0, _utils2.getReserveForPath)(api, paths);
+    const amounts = (0, _utils2.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 (0, _utils2.buildSwapExtrinsic)(api, path, recipient, amountIn, amountOutMin);
+  }
+}
+exports.AssetHubRouter = AssetHubRouter;

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

@@ -0,0 +1,158 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getReserveForPool = exports.getReserveForPath = exports.estimateTokensForPool = exports.estimateTokensForPath = exports.estimateRateForPath = exports.estimateRateAfter = exports.estimatePriceImpactPct = exports.estimateActualRate = exports.checkMinAmountForPool = exports.checkMinAmountForPath = exports.checkLiquidityForPool = exports.checkLiquidityForPath = exports.buildSwapExtrinsic = exports._getPoolInfo = void 0;
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _swap = require("@subwallet/extension-base/types/swap");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const _getPoolInfo = async (api, asset1, asset2) => {
+  const assetLocation1 = (0, _utils._getXcmAssetMultilocation)(asset1);
+  const assetLocation2 = (0, _utils._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()];
+};
+exports._getPoolInfo = _getPoolInfo;
+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];
+  }
+};
+exports.getReserveForPool = getReserveForPool;
+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 _ref => {
+    let [asset1, asset2] = _ref;
+    return getReserveForPool(api, asset1, asset2);
+  }));
+};
+exports.getReserveForPath = getReserveForPath;
+const estimateTokensForPool = (amount, reserves) => {
+  if (amount === '0') {
+    return '0';
+  }
+  return new _bignumber.default(amount).times(reserves[1]).div(reserves[0]).integerValue(_bignumber.default.ROUND_DOWN).toString();
+};
+exports.estimateTokensForPool = estimateTokensForPool;
+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;
+};
+exports.estimateTokensForPath = estimateTokensForPath;
+const estimateRateForPath = reserves => {
+  let result = new _bignumber.default(1);
+  for (const reserve of reserves) {
+    result = result.times(reserve[0]).div(reserve[1]);
+  }
+  return result.toString();
+};
+exports.estimateRateForPath = estimateRateForPath;
+const estimateActualRate = (amount, reserves) => {
+  let result = new _bignumber.default(1);
+  const m = new _bignumber.default(amount);
+
+  // Currently support for direct path swap only
+  for (const reserve of reserves) {
+    const x = new _bignumber.default(reserve[0]);
+    const y = new _bignumber.default(reserve[1]);
+    result = result.times(x.plus(m)).div(y);
+  }
+  return result.toString();
+};
+exports.estimateActualRate = estimateActualRate;
+const estimateRateAfter = (amount, reserves) => {
+  const m = new _bignumber.default(amount);
+  const reserve = reserves[0];
+  const x = new _bignumber.default(reserve[0]);
+  const y = new _bignumber.default(reserve[1]);
+  const n = y.multipliedBy(m).div(x.plus(m));
+  const result = x.plus(m).div(y.minus(n));
+  return result.toString();
+};
+exports.estimateRateAfter = estimateRateAfter;
+const estimatePriceImpactPct = (marketRate, marketRateAfter) => {
+  const bnMarketRate = new _bignumber.default(marketRate);
+  const bnActualRate = new _bignumber.default(marketRateAfter);
+  return new _bignumber.default(1).minus(bnMarketRate.div(bnActualRate)).multipliedBy(100).toString();
+};
+exports.estimatePriceImpactPct = estimatePriceImpactPct;
+const checkLiquidityForPool = (amount, reserve1, reserve2) => {
+  if (new _bignumber.default(reserve1).eq('0') || new _bignumber.default(reserve2).eq('0')) {
+    return _swap.SwapErrorType.ASSET_NOT_SUPPORTED;
+  } else if (new _bignumber.default(reserve1).lt(amount)) {
+    return _swap.SwapErrorType.NOT_ENOUGH_LIQUIDITY;
+  }
+  return undefined;
+};
+exports.checkLiquidityForPool = checkLiquidityForPool;
+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
+exports.checkLiquidityForPath = checkLiquidityForPath;
+const checkMinAmountForPool = (reserve1, reserve2, amount1, amount2, minAmount1, minAmount2) => {
+  const newReserve1 = new _bignumber.default(reserve1).plus(amount1);
+  const newReserve2 = new _bignumber.default(reserve2).minus(amount2);
+  if (newReserve1.lt(minAmount1) || newReserve2.lt(minAmount2)) {
+    return _swap.SwapErrorType.MAKE_POOL_NOT_ENOUGH_EXISTENTIAL_DEPOSIT;
+  }
+  return undefined;
+};
+exports.checkMinAmountForPool = checkMinAmountForPool;
+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
+exports.checkMinAmountForPath = checkMinAmountForPath;
+const buildSwapExtrinsic = function (api, paths, recipient, amountIn, amountOutMin) {
+  let keepAlive = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true;
+  const pathsInfo = paths.map(asset => {
+    const multilocation = (0, _utils._getXcmAssetMultilocation)(asset);
+    return api.createType('MultiLocation', multilocation).toU8a();
+  });
+  return api.tx.assetConversion.swapExactTokensForTokens(pathsInfo, amountIn, amountOutMin, recipient, keepAlive);
+};
+exports.buildSwapExtrinsic = buildSwapExtrinsic;

package/cjs/services/swap-service/index.js

@@ -8,6 +8,7 @@ var _SwapError = require("@subwallet/extension-base/background/errors/SwapError"
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _types = require("@subwallet/extension-base/services/base/types");
+var _assetHub = require("@subwallet/extension-base/services/swap-service/handler/asset-hub");
 var _chainflipHandler = require("@subwallet/extension-base/services/swap-service/handler/chainflip-handler");
 var _hydradxHandler = require("@subwallet/extension-base/services/swap-service/handler/hydradx-handler");
 var _utils = require("@subwallet/extension-base/services/swap-service/utils");
@@ -97,7 +98,6 @@ class SwapService {
       request,
       selectedQuote: swapQuoteResponse.optimalQuote
     });
-    console.log('optimalProcess', optimalProcess);
     return {
       process: optimalProcess,
       quote: swapQuoteResponse
@@ -147,6 +147,15 @@ class SwapService {
         case _swap.SwapProviderId.HYDRADX_MAINNET:
           this.handlers[providerId] = new _hydradxHandler.HydradxHandler(this.chainService, this.state.balanceService, false);
           break;
+        case _swap.SwapProviderId.POLKADOT_ASSET_HUB:
+          this.handlers[providerId] = new _assetHub.AssetHubSwapHandler(this.chainService, this.state.balanceService, 'statemint');
+          break;
+        case _swap.SwapProviderId.KUSAMA_ASSET_HUB:
+          this.handlers[providerId] = new _assetHub.AssetHubSwapHandler(this.chainService, this.state.balanceService, 'statemine');
+          break;
+        case _swap.SwapProviderId.ROCOCO_ASSET_HUB:
+          this.handlers[providerId] = new _assetHub.AssetHubSwapHandler(this.chainService, this.state.balanceService, 'rococo_assethub');
+          break;
         default:
           throw new Error('Unsupported provider');
       }

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

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports._PROVIDER_TO_SUPPORTED_PAIR_MAP = exports.SWAP_QUOTE_TIMEOUT_MAP = exports.CHAIN_FLIP_TESTNET_EXPLORER = exports.CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING = exports.CHAIN_FLIP_MAINNET_EXPLORER = void 0;
 exports.calculateSwapRate = calculateSwapRate;
+exports.convertSwapRate = convertSwapRate;
 exports.getSwapAltToken = getSwapAltToken;
 exports.getSwapAlternativeAsset = getSwapAlternativeAsset;
 var _swap = require("@chainflip/sdk/swap");
@@ -53,7 +54,10 @@ const _PROVIDER_TO_SUPPORTED_PAIR_MAP = {
   [_swap2.SwapProviderId.HYDRADX_MAINNET]: [_chainList.COMMON_CHAIN_SLUGS.HYDRADX],
   [_swap2.SwapProviderId.HYDRADX_TESTNET]: [_chainList.COMMON_CHAIN_SLUGS.HYDRADX_TESTNET],
   [_swap2.SwapProviderId.CHAIN_FLIP_MAINNET]: [_chainList.COMMON_CHAIN_SLUGS.POLKADOT, _chainList.COMMON_CHAIN_SLUGS.ETHEREUM],
-  [_swap2.SwapProviderId.CHAIN_FLIP_TESTNET]: [_chainList.COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT, _chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA]
+  [_swap2.SwapProviderId.CHAIN_FLIP_TESTNET]: [_chainList.COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT, _chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA],
+  [_swap2.SwapProviderId.POLKADOT_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.POLKADOT_ASSET_HUB],
+  [_swap2.SwapProviderId.KUSAMA_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.KUSAMA_ASSET_HUB],
+  [_swap2.SwapProviderId.ROCOCO_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.ROCOCO_ASSET_HUB]
 };
 exports._PROVIDER_TO_SUPPORTED_PAIR_MAP = _PROVIDER_TO_SUPPORTED_PAIR_MAP;
 function getSwapAlternativeAsset(swapPair) {
@@ -70,4 +74,9 @@ function calculateSwapRate(fromAmount, toAmount, fromAsset, toAsset) {
   const decimalDiff = (0, _utils._getAssetDecimals)(toAsset) - (0, _utils._getAssetDecimals)(fromAsset);
   const bnRate = bnFromAmount.div(bnToAmount);
   return 1 / bnRate.times(10 ** decimalDiff).toNumber();
+}
+function convertSwapRate(rate, fromAsset, toAsset) {
+  const decimalDiff = (0, _utils._getAssetDecimals)(toAsset) - (0, _utils._getAssetDecimals)(fromAsset);
+  const bnRate = new _bignumber.default(rate);
+  return bnRate.times(10 ** decimalDiff).pow(-1).toNumber();
 }