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

package/cjs/services/price-service/coingecko.js

@@ -5,15 +5,25 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.getPriceMap = exports.getExchangeRateMap = void 0;
 var _staticData = require("@subwallet/extension-base/utils/staticData");
+var _util = require("@polkadot/util");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
 const DEFAULT_CURRENCY = 'USD';
 let useBackupApi = false;
 const getExchangeRateMap = async () => {
+  let response;
   try {
-    const response = await fetch('https://api-cache.subwallet.app/exchange-rate');
-    const responseDataExchangeRate = (await response.json()) || {};
+    var _response, _response2;
+    try {
+      response = await fetch('https://api-cache.subwallet.app/exchange-rate');
+    } catch (e) {}
+    if (((_response = response) === null || _response === void 0 ? void 0 : _response.status) !== 200) {
+      try {
+        response = await fetch('https://static-cache.subwallet.app/exchange-rate/data.json');
+      } catch (e) {}
+    }
+    const responseDataExchangeRate = (await ((_response2 = response) === null || _response2 === void 0 ? void 0 : _response2.json())) || {};
     const exchangeRateMap = Object.keys(responseDataExchangeRate.conversion_rates).reduce((map, exchangeKey) => {
       if (!_staticData.staticData[_staticData.StaticKey.CURRENCY_SYMBOL][exchangeKey]) {
         return map;
@@ -26,45 +36,60 @@ const getExchangeRateMap = async () => {
     }, {});
     return exchangeRateMap;
   } catch (e) {
-    console.warn('Failed to get exchange rate');
     return {};
   }
 };
 exports.getExchangeRateMap = getExchangeRateMap;
 const getPriceMap = async function (priceIds) {
-  var _rs, _rs2;
   let currency = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'USD';
   const idStr = Array.from(priceIds).join(',');
-  let rs;
-  if (!useBackupApi) {
-    try {
-      rs = await fetch(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=${currency.toLowerCase()}&per_page=250&ids=${idStr}`);
-    } catch (err) {
+  let response;
+  try {
+    var _response3, _response5;
+    if (!useBackupApi) {
+      try {
+        response = await fetch(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=${currency.toLowerCase()}&per_page=250&ids=${idStr}`);
+      } catch (err) {
+        useBackupApi = true;
+      }
+    }
+    if (useBackupApi || ((_response3 = response) === null || _response3 === void 0 ? void 0 : _response3.status) !== 200) {
+      var _response4;
       useBackupApi = true;
+      try {
+        response = await fetch(`https://api-cache.subwallet.app/api/price/get?ids=${idStr}`);
+      } catch (e) {}
+      if (((_response4 = response) === null || _response4 === void 0 ? void 0 : _response4.status) !== 200) {
+        try {
+          response = await fetch('https://static-cache.subwallet.app/price/data.json');
+        } catch (e) {}
+      }
     }
+    const generateDataPriceRaw = (await ((_response5 = response) === null || _response5 === void 0 ? void 0 : _response5.json())) || [];
+    const responseDataPrice = (0, _util.isArray)(generateDataPriceRaw) ? generateDataPriceRaw : Object.entries(generateDataPriceRaw).map(_ref => {
+      let [id, value] = _ref;
+      return {
+        ...value,
+        id
+      };
+    });
+    const currencyData = _staticData.staticData[_staticData.StaticKey.CURRENCY_SYMBOL][currency || DEFAULT_CURRENCY];
+    const priceMap = {};
+    const price24hMap = {};
+    responseDataPrice.forEach(val => {
+      const currentPrice = val.current_price || 0;
+      const price24h = currentPrice - (val.price_change_24h || 0);
+      priceMap[val.id] = currentPrice;
+      price24hMap[val.id] = price24h;
+    });
+    return {
+      currency,
+      currencyData,
+      priceMap,
+      price24hMap
+    };
+  } catch (e) {
+    return {};
   }
-  if (useBackupApi || ((_rs = rs) === null || _rs === void 0 ? void 0 : _rs.status) !== 200) {
-    useBackupApi = true;
-    rs = await fetch(`https://chain-data.subwallet.app/api/price/get?ids=${idStr}`);
-  }
-  if (((_rs2 = rs) === null || _rs2 === void 0 ? void 0 : _rs2.status) !== 200) {
-    console.warn('Failed to get token price');
-  }
-  const responseDataPrice = (await rs.json()) || [];
-  const currencyData = _staticData.staticData[_staticData.StaticKey.CURRENCY_SYMBOL][currency || DEFAULT_CURRENCY];
-  const priceMap = {};
-  const price24hMap = {};
-  responseDataPrice.forEach(val => {
-    const currentPrice = val.current_price || 0;
-    const price24h = currentPrice - (val.price_change_24h || 0);
-    priceMap[val.id] = currentPrice;
-    price24hMap[val.id] = price24h;
-  });
-  return {
-    currency,
-    currencyData,
-    priceMap,
-    price24hMap
-  };
 };
 exports.getPriceMap = getPriceMap;

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

@@ -9,6 +9,7 @@ var _types = require("@subwallet/extension-base/services/base/types");
 var _coingecko = require("@subwallet/extension-base/services/price-service/coingecko");
 var _storage = require("@subwallet/extension-base/storage");
 var _stores = require("@subwallet/extension-base/stores");
+var _utils = require("@subwallet/extension-base/utils");
 var _promise = require("@subwallet/extension-base/utils/promise");
 var _staticData = require("@subwallet/extension-base/utils/staticData");
 var _rxjs = require("rxjs");
@@ -28,6 +29,9 @@ const DEFAULT_PRICE_SUBJECT = {
   price24hMap: {},
   exchangeRateMap: {}
 };
+const checkFetchSuccess = (obj1, obj2) => {
+  return Object.keys(obj1).length > 0 && Object.keys(obj2).length > 0;
+};
 class PriceService {
   priceIds = new Set();
   currency = new _stores.CurrentCurrencyStore();
@@ -49,11 +53,16 @@ class PriceService {
     this.init().then(() => this.getCurrentCurrency(updateCurrency)).catch(console.error);
   }
   async getTokenPrice(priceIds, currency, resolve, reject) {
-    await Promise.all([(0, _coingecko.getExchangeRateMap)(), (0, _coingecko.getPriceMap)(priceIds, currency)]).then(_ref => {
-      let [exchangeRateMap, priceMap] = _ref;
-      this.rawExchangeRateMap.next(exchangeRateMap);
-      this.rawPriceSubject.next(priceMap);
-    });
+    const getPriceData = async () => {
+      await Promise.all([(0, _coingecko.getExchangeRateMap)(), (0, _coingecko.getPriceMap)(priceIds, currency)]).then(_ref => {
+        let [exchangeRateMap, priceMap] = _ref;
+        if (checkFetchSuccess(priceMap, exchangeRateMap)) {
+          this.rawExchangeRateMap.next(exchangeRateMap);
+          this.rawPriceSubject.next(priceMap);
+        }
+      });
+    };
+    await Promise.race([getPriceData(), (0, _utils.wait)(10 * 1000)]);
   }
   getCurrentCurrencySubject() {
     return this.currency.getSubject();
@@ -89,17 +98,27 @@ class PriceService {
     })();
   }
   async calculatePriceMap(currency) {
-    const {
+    let {
       price24hMap,
       priceMap
     } = this.rawPriceSubject.value;
-    const exchangeRateData = this.rawExchangeRateMap.value;
+    let exchangeRateData = this.rawExchangeRateMap.value;
+    const priceStored = await this.dbService.getPriceStore(currency);
     const currencyKey = currency || DEFAULT_CURRENCY;
     if (Object.keys(this.rawPriceSubject.value).length === 0) {
-      return;
+      if (priceStored !== null && priceStored !== void 0 && priceStored.exchangeRateMap) {
+        exchangeRateData = priceStored.exchangeRateMap;
+      }
     }
     if (Object.keys(exchangeRateData).length === 0) {
-      return;
+      if (priceStored !== null && priceStored !== void 0 && priceStored.price24hMap) {
+        price24hMap = {
+          ...priceStored.price24hMap
+        };
+        priceMap = {
+          ...priceStored.priceMap
+        };
+      }
     }
     const finalPriceMap = {
       priceMap: {
@@ -165,8 +184,8 @@ class PriceService {
         this.refreshPriceMapByAction();
       }
     };
-    this.getCurrentCurrencySubject().subscribe(currency => {
-      console.log('Currency changed', currency);
+    (0, _rxjs.combineLatest)([this.getCurrentCurrencySubject(), this.rawPriceSubject, this.rawExchangeRateMap]).subscribe(_ref2 => {
+      let [currency] = _ref2;
       this.calculatePriceMap(currency).then(data => {
         if (data) {
           this.priceSubject.next(data);

package/cjs/services/storage-service/db-stores/BaseStore.js

@@ -22,6 +22,10 @@ class BaseStore {
   bulkUpsert(records) {
     return this.table.bulkPut(records);
   }
+
+  /**
+   * @todo Must update, delete function need the key not the record
+   * */
   remove(record) {
     return this.table.delete(record);
   }

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;