@subwallet/extension-base 1.3.29-1 → 1.3.31-0

package/cjs/services/swap-service/handler/uniswap-handler.js

@@ -8,11 +8,11 @@ exports.UniswapHandler = void 0;
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _logicValidation = require("@subwallet/extension-base/core/logic-validation");
-var _interface = require("@subwallet/extension-base/services/swap-service/interface");
 var _types = require("@subwallet/extension-base/types");
+var _utils = require("@subwallet/extension-base/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
-var _utils = require("../../chain-service/utils");
-var _utils2 = require("../../fee-service/utils");
+var _utils2 = require("../../chain-service/utils");
+var _utils3 = require("../../fee-service/utils");
 var _baseHandler = require("./base-handler");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
@@ -65,13 +65,10 @@ class UniswapHandler {
   get providerInfo() {
     return this.swapBaseHandler.providerInfo;
   }
-  generateOptimalProcess(params) {
-    return this.swapBaseHandler.generateOptimalProcess(params, [this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
-  }
   generateOptimalProcessV2(params) {
     return this.swapBaseHandler.generateOptimalProcessV2(params, [this.getApprovalStep.bind(this), this.getPermitStep.bind(this), this.getSubmitStep.bind(this)]);
   }
-  async getApprovalStep(params) {
+  async getApprovalStep(params, stepIndex) {
     if (params.selectedQuote) {
       const walletAddress = params.request.address;
       const fromAmount = params.selectedQuote.fromAmount;
@@ -91,7 +88,7 @@ class UniswapHandler {
         }
         const metadata = {
           tokenApprove: inputTokenInfo.slug,
-          contractAddress: (0, _utils._getContractAddressOfToken)(inputTokenInfo),
+          contractAddress: (0, _utils2._getContractAddressOfToken)(inputTokenInfo),
           spenderAddress: spender
         };
         const submitStep = {
@@ -104,7 +101,7 @@ class UniswapHandler {
     }
     return Promise.resolve(undefined);
   }
-  async getPermitStep(params) {
+  async getPermitStep(params, stepIndex) {
     if (params.selectedQuote && params.selectedQuote.metadata.permitData) {
       const submitStep = {
         name: 'Permit Step',
@@ -125,47 +122,29 @@ class UniswapHandler {
     }
     return Promise.resolve(undefined);
   }
-  async getSubmitStep(params) {
-    if (params.selectedQuote) {
-      const submitStep = {
-        name: 'Swap',
-        type: _types.SwapStepType.SWAP,
-        metadata: {
-          sendingValue: params.request.fromAmount.toString(),
-          originTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.from),
-          destinationTokenInfo: this.chainService.getAssetBySlug(params.selectedQuote.pair.to)
-        }
-      };
-      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
-    }
-    return Promise.resolve(undefined);
-  }
-  async validateSwapProcess(params) {
-    const amount = params.selectedQuote.fromAmount;
-    const bnAmount = BigInt(amount);
-    if (bnAmount <= BigInt(0)) {
-      return Promise.resolve([new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')]);
+  async getSubmitStep(params, stepIndex) {
+    if (!params.selectedQuote) {
+      return Promise.resolve(undefined);
     }
-    let isXcmOk = false;
-    for (const [index, step] of params.process.steps.entries()) {
-      const getErrors = async () => {
-        switch (step.type) {
-          case _types.CommonStepType.DEFAULT:
-            return Promise.resolve([]);
-          case _types.CommonStepType.TOKEN_APPROVAL:
-            return Promise.resolve([]);
-          default:
-            return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
-        }
-      };
-      const errors = await getErrors();
-      if (errors.length) {
-        return errors;
-      } else if (step.type === _types.CommonStepType.XCM) {
-        isXcmOk = true;
+    const originTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.from);
+    const destinationTokenInfo = this.chainService.getAssetBySlug(params.selectedQuote.pair.to);
+    const originChain = this.chainService.getChainInfoByKey(originTokenInfo.originChain);
+    const destinationChain = this.chainService.getChainInfoByKey(destinationTokenInfo.originChain);
+    const submitStep = {
+      name: 'Swap',
+      type: _types.SwapStepType.SWAP,
+      // @ts-ignore
+      metadata: {
+        sendingValue: params.request.fromAmount.toString(),
+        expectedReceive: params.selectedQuote.toAmount,
+        originTokenInfo,
+        destinationTokenInfo,
+        sender: (0, _utils._reformatAddressWithChain)(params.request.address, originChain),
+        receiver: (0, _utils._reformatAddressWithChain)(params.request.recipient || params.request.address, destinationChain),
+        version: 2
       }
-    }
-    return [];
+    };
+    return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
   }
   async handleSwapProcess(params) {
     const {
@@ -199,7 +178,7 @@ class UniswapHandler {
     if (approval) {
       var _priority$options, _priority$options$Fee, _priority$options2;
       const evmApi = this.chainService.getEvmApi(fromAsset.originChain);
-      const priority = await (0, _utils2.calculateGasFeeParams)(evmApi, evmApi.chainSlug);
+      const priority = await (0, _utils3.calculateGasFeeParams)(evmApi, evmApi.chainSlug);
       transactionConfig = {
         from: approval.from,
         to: approval.to,
@@ -286,7 +265,7 @@ class UniswapHandler {
       txChain: fromAsset.originChain,
       txData,
       extrinsic: extrinsic,
-      transferNativeAmount: (0, _utils._isNativeToken)(fromAsset) ? params.quote.fromAmount : '0',
+      transferNativeAmount: (0, _utils2._isNativeToken)(fromAsset) ? params.quote.fromAmount : '0',
       extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
       chainType: _KoniTypes.ChainType.EVM
     };
@@ -349,10 +328,10 @@ class UniswapHandler {
       return [new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
     }
     const actionList = JSON.stringify(process.path.map(step => step.action));
-    const swap = actionList === JSON.stringify([_interface.DynamicSwapType.SWAP]);
-    const swapXcm = actionList === JSON.stringify([_interface.DynamicSwapType.SWAP, _interface.DynamicSwapType.BRIDGE]);
-    const xcmSwap = actionList === JSON.stringify([_interface.DynamicSwapType.BRIDGE, _interface.DynamicSwapType.SWAP]);
-    const xcmSwapXcm = actionList === JSON.stringify([_interface.DynamicSwapType.BRIDGE, _interface.DynamicSwapType.SWAP, _interface.DynamicSwapType.BRIDGE]);
+    const swap = actionList === JSON.stringify([_types.DynamicSwapType.SWAP]);
+    const swapXcm = actionList === JSON.stringify([_types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
+    const xcmSwap = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP]);
+    const xcmSwapXcm = actionList === JSON.stringify([_types.DynamicSwapType.BRIDGE, _types.DynamicSwapType.SWAP, _types.DynamicSwapType.BRIDGE]);
     const swapIndex = params.process.steps.findIndex(step => step.type === _types.SwapStepType.SWAP); // todo
 
     if (swapIndex <= -1) {

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

@@ -4,37 +4,38 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports._isChainSupportedByProvider = exports.SwapService = void 0;
+exports.SwapService = void 0;
+var _chainList = require("@subwallet/chain-list");
+var _types = require("@subwallet/chain-list/types");
 var _SwapError = require("@subwallet/extension-base/background/errors/SwapError");
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
-var _types = require("@subwallet/extension-base/services/base/types");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _types2 = require("@subwallet/extension-base/services/base/types");
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
 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 _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
-var _types2 = require("@subwallet/extension-base/types");
+var _types3 = require("@subwallet/extension-base/types");
 var _serviceBase = require("@subwallet/extension-base/types/service-base");
 var _swap = require("@subwallet/extension-base/types/swap");
 var _utils3 = require("@subwallet/extension-base/utils");
 var _subwalletApiSdk = _interopRequireDefault(require("@subwallet/subwallet-api-sdk"));
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _i18next = require("i18next");
 var _rxjs = require("rxjs");
 var _simpleswapHandler = require("./handler/simpleswap-handler");
 var _uniswapHandler = require("./handler/uniswap-handler");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
-const _isChainSupportedByProvider = (providerSlug, chain) => {
-  const supportedChains = _utils2._PROVIDER_TO_SUPPORTED_PAIR_MAP[providerSlug];
-  return supportedChains ? supportedChains.includes(chain) : false;
-};
-exports._isChainSupportedByProvider = _isChainSupportedByProvider;
 class SwapService {
   swapPairSubject = new _rxjs.BehaviorSubject([]);
   handlers = {};
   startPromiseHandler = (0, _utils3.createPromiseHandler)();
   stopPromiseHandler = (0, _utils3.createPromiseHandler)();
-  status = _types.ServiceStatus.NOT_INITIALIZED;
+  status = _types2.ServiceStatus.NOT_INITIALIZED;
   constructor(state) {
     this.state = state;
     this.eventService = state.eventService;
@@ -43,13 +44,6 @@ class SwapService {
   async askProvidersForQuote(request) {
     var _subwalletApiSdk$swap;
     const availableQuotes = [];
-    await Promise.all(Object.values(this.handlers).map(async handler => {
-      // temporary solution to reduce number of requests to providers, will work as long as there's only 1 provider for 1 chain
-
-      if (handler.init && handler.isReady === false) {
-        await handler.init();
-      }
-    }));
     const quotes = await ((_subwalletApiSdk$swap = _subwalletApiSdk.default.swapApi) === null || _subwalletApiSdk$swap === void 0 ? void 0 : _subwalletApiSdk$swap.fetchSwapQuoteData(request));
     if (Array.isArray(quotes)) {
       quotes.forEach(quoteData => {
@@ -69,32 +63,17 @@ class SwapService {
     }
     return availableQuotes;
   }
-  getDefaultProcess(params) {
-    const result = {
-      totalFee: [_serviceBase.MOCK_STEP_FEE],
-      steps: [_serviceBase.DEFAULT_FIRST_STEP],
-      path: []
-    };
-    result.totalFee.push({
-      feeComponent: [],
-      feeOptions: [params.request.pair.from],
-      defaultFeeToken: params.request.pair.from
-    });
-    result.steps.push({
-      id: result.steps.length,
-      name: 'Swap',
-      type: _swap.SwapStepType.SWAP
-    });
-    return result;
-  }
   getDefaultProcessV2(params) {
     const result = {
       totalFee: [_serviceBase.MOCK_STEP_FEE],
       steps: [_serviceBase.DEFAULT_FIRST_STEP],
       path: []
     };
-    const swapPairInfo = params.path[0].pair; // todo: improve for Round 2
-
+    const swapPairInfo = params.path.find(action => action.action === _types3.DynamicSwapType.SWAP);
+    if (!swapPairInfo) {
+      console.error('Swap pair is not found');
+      return result;
+    }
     result.totalFee.push({
       feeComponent: [],
       feeOptions: [params.request.pair.from],
@@ -106,34 +85,18 @@ class SwapService {
       type: _swap.SwapStepType.SWAP,
       metadata: {
         sendingValue: params.request.fromAmount.toString(),
-        originTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.from),
-        destinationTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.to)
+        originTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.pair.from),
+        destinationTokenInfo: this.chainService.getAssetBySlug(swapPairInfo.pair.to)
       }
     });
     return result;
   }
-
-  // deprecated
-  async generateOptimalProcess(params) {
-    if (!params.selectedQuote) {
-      return this.getDefaultProcess(params);
-    } else {
-      var _params$request$curre;
-      const providerId = ((_params$request$curre = params.request.currentQuote) === null || _params$request$curre === void 0 ? void 0 : _params$request$curre.id) || params.selectedQuote.provider.id;
-      const handler = this.handlers[providerId];
-      if (handler) {
-        return handler.generateOptimalProcess(params);
-      } else {
-        return this.getDefaultProcess(params);
-      }
-    }
-  }
   async generateOptimalProcessV2(params) {
     if (!params.selectedQuote) {
       return this.getDefaultProcessV2(params);
     } else {
-      var _params$request$curre2;
-      const providerId = ((_params$request$curre2 = params.request.currentQuote) === null || _params$request$curre2 === void 0 ? void 0 : _params$request$curre2.id) || params.selectedQuote.provider.id;
+      var _params$request$curre;
+      const providerId = ((_params$request$curre = params.request.currentQuote) === null || _params$request$curre === void 0 ? void 0 : _params$request$curre.id) || params.selectedQuote.provider.id;
       const handler = this.handlers[providerId];
       if (handler) {
         return handler.generateOptimalProcessV2(params);
@@ -142,48 +105,6 @@ class SwapService {
       }
     }
   }
-  async generateOptimalProcessWithoutPath(params) {
-    var _params$request$curre3;
-    if (!params.selectedQuote || params.path.length > 0) {
-      return this.getDefaultProcessV2(params);
-    }
-    const [path, directSwapRequest] = this.getAvailablePath(params.request);
-    if (!directSwapRequest) {
-      return this.getDefaultProcessV2(params);
-    }
-    params.path = path;
-    const providerId = ((_params$request$curre3 = params.request.currentQuote) === null || _params$request$curre3 === void 0 ? void 0 : _params$request$curre3.id) || params.selectedQuote.provider.id;
-    const handler = this.handlers[providerId];
-    if (handler) {
-      return handler.generateOptimalProcessV2(params);
-    } else {
-      return this.getDefaultProcessV2(params);
-    }
-  }
-
-  // deprecated
-  // eslint-disable-next-line @typescript-eslint/require-await
-  async handleSwapRequest(request) {
-    /*
-    * 1. Ask swap quotes from providers
-    * 2. Select the best quote
-    * 3. Generate optimal process for that quote
-    * */
-
-    // const swapQuoteResponse = await this.getLatestDirectQuotes(request);
-
-    // const optimalProcess = await this.generateOptimalProcess({
-    //   request,
-    //   selectedQuote: swapQuoteResponse.optimalQuote
-    // });
-
-    return {
-      // @ts-ignore
-      process: null,
-      // @ts-ignore
-      quote: null
-    };
-  }
   async handleSwapRequestV2(request) {
     /*
     * 1. Find available path
@@ -192,14 +113,6 @@ class SwapService {
     * 4. Generate optimal process for that quote
     * */
 
-    // todo: path will become a list of path in Round 2
-    // const [path, directSwapRequest] = this.getAvailablePath(request);
-    //
-    // if (!directSwapRequest) {
-    //   throw Error('Swap pair not found');
-    // }
-
-    // const swapQuoteResponse = await this.getLatestDirectQuotes(directSwapRequest);
     const {
       path,
       swapQuoteResponse
@@ -209,63 +122,131 @@ class SwapService {
       selectedQuote: swapQuoteResponse.optimalQuote,
       path
     });
+    console.log('-------');
+    console.log('optimalProcess', optimalProcess);
+    console.log('-------');
+    if (optimalProcess.steps.length - 1 < optimalProcess.path.length) {
+      // minus the fill info step
+      throw new Error('Swap pair is not found');
+    }
     return {
       process: optimalProcess,
       quote: swapQuoteResponse
     };
   }
+
+  // todo: rewrite this function
   getAvailablePath(request) {
     const {
+      address,
       pair
     } = request;
     // todo: control provider tighter
-    const allSupportedChainsBySwapProvider = [...new Set(Object.values(_utils2._PROVIDER_TO_SUPPORTED_PAIR_MAP).flat())];
+    const supportSwapChains = (0, _utils2.getSupportSwapChain)();
     const fromToken = this.chainService.getAssetBySlug(pair.from);
     const toToken = this.chainService.getAssetBySlug(pair.to);
     const fromChain = (0, _utils._getAssetOriginChain)(fromToken);
     const toChain = (0, _utils._getAssetOriginChain)(toToken);
     const toChainInfo = this.chainService.getChainInfoByKey(toChain);
-    const process = [];
+    const assetRefMap = this.chainService.getAssetRefMap();
+    let process = [];
     if (!fromToken || !toToken) {
       throw Error('Token not found');
     }
     if (!fromChain || !toChain) {
       throw Error('Token metadata error');
     }
+    const directXcmRef = Object.values(assetRefMap).find(assetRef => assetRef.path === _types._AssetRefPath.XCM && assetRef.srcAsset === fromToken.slug && assetRef.destAsset === toToken.slug);
+    if (directXcmRef) {
+      return [[], undefined];
+    }
 
     // SWAP: 2 tokens in the same chain and chain has dex
     if ((0, _utils2.isChainsHasSameProvider)(fromChain, toChain)) {
       // there's a dex that can support direct swapping
-      const swapStep = (0, _utils2.getSwapStep)(fromToken.slug, toToken.slug);
+      process.push((0, _utils2.getSwapStep)(fromToken.slug, toToken.slug));
+      return [process, request];
+    }
+
+    // ------------------------
+    // BRIDGE -> SWAP: Try to find a token in dest chain that can bridge from fromToken
+    const bridgeTransit = (0, _utils2.findBridgeTransitDestination)(assetRefMap, fromToken, toToken);
+    if (bridgeTransit && supportSwapChains.includes(toChain)) {
+      const swapStep = (0, _utils2.getSwapStep)(bridgeTransit, toToken.slug);
+      process.push((0, _utils2.getBridgeStep)(fromToken.slug, bridgeTransit));
       process.push(swapStep);
       return [process, {
         ...request,
+        address: (0, _utils3.reformatAddress)(address, (0, _utils._getChainSubstrateAddressPrefix)(toChainInfo)),
         pair: swapStep.pair
       }];
     }
 
-    // BRIDGE -> SWAP: Try to find a token in dest chain that can bridge from fromToken
-    const bridgeDestination = (0, _utils2.findXcmDestination)(this.chainService.getAssetRefMap(), fromToken, toChain);
-    if (bridgeDestination && allSupportedChainsBySwapProvider.includes(toChain)) {
-      const bridgeStep = (0, _utils2.getBridgeStep)(fromToken.slug, bridgeDestination);
-      const swapStep = (0, _utils2.getSwapStep)(bridgeDestination, toToken.slug);
-      process.push(bridgeStep);
+    // ------------------------
+    // SWAP -> BRIDGE: Try to find a token in from chain that can bridge to toToken
+    const swapTransit = (0, _utils2.findSwapTransitDestination)(assetRefMap, fromToken, toToken);
+    if (swapTransit && supportSwapChains.includes(fromChain)) {
+      const swapStep = (0, _utils2.getSwapStep)(fromToken.slug, swapTransit);
       process.push(swapStep);
+      process.push((0, _utils2.getBridgeStep)(swapTransit, toToken.slug));
       return [process, {
         ...request,
-        address: (0, _utils3.reformatAddress)(request.address, (0, _utils._getChainSubstrateAddressPrefix)(toChainInfo)),
         pair: swapStep.pair
       }];
     }
 
-    // todo: improve to support SWAP -> BRIDGE and BRIDGE -> SWAP -> BRIDGE
+    // ------------------------
+    // BRIDGE -> SWAP -> BRIDGE: Try to find a tri-step path to swap
+    const processList = [];
+    const swapPairList = [];
+    const allBridgeDestinations = (0, _utils2.findAllBridgeDestinations)(assetRefMap, fromToken);
+
+    // currently find first path. Todo: return all paths or best path.
+    for (const bridgeTransit of allBridgeDestinations) {
+      process = [];
+      const bridgeDestinationInfo = this.chainService.getAssetBySlug(bridgeTransit);
+      const swapTransit = (0, _utils2.findSwapTransitDestination)(assetRefMap, bridgeDestinationInfo, toToken);
+      if (bridgeTransit === swapTransit) {
+        continue;
+      }
+      if (swapTransit && supportSwapChains.includes(bridgeDestinationInfo.originChain)) {
+        const swapStep = (0, _utils2.getSwapStep)(bridgeTransit, swapTransit);
+        process.push((0, _utils2.getBridgeStep)(fromToken.slug, bridgeTransit));
+        process.push(swapStep);
+        process.push((0, _utils2.getBridgeStep)(swapTransit, toToken.slug));
+
+        // set the highest priority to hydration provider
+        if (bridgeDestinationInfo.originChain === _chainList.COMMON_CHAIN_SLUGS.HYDRADX) {
+          return [process, {
+            ...request,
+            address: (0, _utils3._reformatAddressWithChain)(address, this.chainService.getChainInfoByKey(_chainList.COMMON_CHAIN_SLUGS.HYDRADX)),
+            pair: swapStep.pair
+          }];
+        }
+        processList.push(process);
+        swapPairList.push(swapStep.pair);
+      }
+    }
+
+    // get first process
+    if (processList.length && swapPairList.length) {
+      const [firstProcess, firstSwapPair] = [processList[0], swapPairList[0]];
+      const chainSwap = this.chainService.getAssetBySlug(firstSwapPair.from).originChain;
+      return [firstProcess, {
+        ...request,
+        address: (0, _utils3._reformatAddressWithChain)(address, this.chainService.getChainInfoByKey(chainSwap)),
+        pair: firstSwapPair
+      }];
+    }
+
+    // todo: encapsulate each route type to function
 
     return [[], undefined];
   }
   async getLatestQuoteFromSwapRequest(request) {
     const [path, directSwapRequest] = this.getAvailablePath(request);
     if (!directSwapRequest) {
-      throw Error('Swap pair not found');
+      throw Error('Swap pair is not found');
     }
     const swapQuoteResponse = await this.getLatestDirectQuotes(directSwapRequest);
     return {
@@ -292,12 +273,32 @@ class SwapService {
       quoteError = (preferredErrorResp === null || preferredErrorResp === void 0 ? void 0 : preferredErrorResp.error) || (defaultErrorResp === null || defaultErrorResp === void 0 ? void 0 : defaultErrorResp.error);
     } else {
       var _selectedQuote;
-      selectedQuote = availableQuotes.find(quote => {
-        var _request$currentQuote;
-        return quote.provider.id === ((_request$currentQuote = request.currentQuote) === null || _request$currentQuote === void 0 ? void 0 : _request$currentQuote.id);
-      }) || availableQuotes[0]; // todo: choose best quote based on rate
+      // sort quotes by largest receivable, with priority for some providers
+      availableQuotes.sort((a, b) => {
+        const bnToAmountA = (0, _bignumber.default)(a.toAmount);
+        const bnToAmountB = (0, _bignumber.default)(b.toAmount);
+        if (bnToAmountB.eq(bnToAmountA) && [_swap.SwapProviderId.CHAIN_FLIP_MAINNET, _swap.SwapProviderId.UNISWAP].includes(a.provider.id)) {
+          return -1;
+        }
+        if (bnToAmountA.gt(bnToAmountB)) {
+          return -1;
+        } else {
+          return 1;
+        }
+      });
+      if (request.preferredProvider) {
+        selectedQuote = availableQuotes.find(quote => quote.provider.id === request.preferredProvider) || availableQuotes[0];
+      } else {
+        selectedQuote = availableQuotes[0];
+      }
       aliveUntil = ((_selectedQuote = selectedQuote) === null || _selectedQuote === void 0 ? void 0 : _selectedQuote.aliveUntil) || +Date.now() + _utils2.SWAP_QUOTE_TIMEOUT_MAP.default;
     }
+    const neededProviders = availableQuotes.map(quote => quote.provider.id);
+    await Promise.all(Object.values(this.handlers).map(async handler => {
+      if (neededProviders.includes(handler.providerSlug) && handler.init && handler.isReady === false) {
+        await handler.init();
+      }
+    }));
     return {
       optimalQuote: selectedQuote,
       quotes: availableQuotes,
@@ -344,20 +345,20 @@ class SwapService {
     });
   }
   async init() {
-    this.status = _types.ServiceStatus.INITIALIZING;
+    this.status = _types2.ServiceStatus.INITIALIZING;
     this.eventService.emit('swap.ready', true);
-    this.status = _types.ServiceStatus.INITIALIZED;
+    this.status = _types2.ServiceStatus.INITIALIZED;
     this.initHandlers();
     await this.start();
   }
   async start() {
-    if (this.status === _types.ServiceStatus.STOPPING) {
+    if (this.status === _types2.ServiceStatus.STOPPING) {
       await this.waitForStopped();
     }
-    if (this.status === _types.ServiceStatus.STARTED || this.status === _types.ServiceStatus.STARTING) {
+    if (this.status === _types2.ServiceStatus.STARTED || this.status === _types2.ServiceStatus.STARTING) {
       return this.waitForStarted();
     }
-    this.status = _types.ServiceStatus.STARTING;
+    this.status = _types2.ServiceStatus.STARTING;
 
     // todo: start the service jobs, subscribe data,...
 
@@ -366,13 +367,13 @@ class SwapService {
     // Update promise handler
     this.startPromiseHandler.resolve();
     this.stopPromiseHandler = (0, _utils3.createPromiseHandler)();
-    this.status = _types.ServiceStatus.STARTED;
+    this.status = _types2.ServiceStatus.STARTED;
   }
   async stop() {
-    if (this.status === _types.ServiceStatus.STARTING) {
+    if (this.status === _types2.ServiceStatus.STARTING) {
       await this.waitForStarted();
     }
-    if (this.status === _types.ServiceStatus.STOPPED || this.status === _types.ServiceStatus.STOPPING) {
+    if (this.status === _types2.ServiceStatus.STOPPED || this.status === _types2.ServiceStatus.STOPPING) {
       return this.waitForStopped();
     }
 
@@ -380,7 +381,7 @@ class SwapService {
 
     this.stopPromiseHandler.resolve();
     this.startPromiseHandler = (0, _utils3.createPromiseHandler)();
-    this.status = _types.ServiceStatus.STOPPED;
+    this.status = _types2.ServiceStatus.STOPPED;
   }
   waitForStarted() {
     return this.startPromiseHandler.promise;
@@ -402,35 +403,45 @@ class SwapService {
       };
     });
   }
-
-  // private getSwapPairMetadata (slug: string): Record<string, any> | undefined {
-  //   return this.getSwapPairs().find((pair) => pair.slug === slug)?.metadata;
-  // }
-
-  async validateSwapProcess(params) {
+  async validateSwapProcessV2(params) {
     const providerId = params.selectedQuote.provider.id;
     const handler = this.handlers[providerId];
-    if (params.currentStep > 1) {
-      // only validate from the first step
+    if (params.currentStep > 0) {
       return [];
     }
+    const blockedConfigObjects = await (0, _constants.fetchBlockedConfigObjects)();
+    const currentConfig = this.state.settingService.getEnvironmentSetting();
+    const passBlockedConfigId = (0, _constants.getPassConfigId)(currentConfig, blockedConfigObjects);
+    const blockedActionsFeaturesMaps = await (0, _constants.fetchLatestBlockedActionsAndFeatures)(passBlockedConfigId);
+    const originSwapPairInfo = (0, _utils2.getTokenPairFromStep)(params.process.steps);
+    if (!originSwapPairInfo) {
+      return [new _TransactionError.TransactionError(_types3.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    const currentAction = `${_KoniTypes.ExtrinsicType.SWAP}___${originSwapPairInfo.slug}___${params.selectedQuote.provider.id}`;
+    for (const blockedActionsFeaturesMap of blockedActionsFeaturesMaps) {
+      const {
+        blockedActionsMap
+      } = blockedActionsFeaturesMap;
+      if (blockedActionsMap.swap.includes(currentAction)) {
+        return [new _TransactionError.TransactionError(_types3.BasicTxErrorType.UNSUPPORTED, (0, _i18next.t)('Feature under maintenance. Try again later'))];
+      }
+    }
     if (handler) {
       return handler.validateSwapProcessV2(params);
     } else {
-      return [new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR)];
+      return [new _TransactionError.TransactionError(_types3.BasicTxErrorType.INTERNAL_ERROR)];
     }
   }
   async handleSwapProcess(params) {
     const handler = this.handlers[params.quote.provider.id];
     if (params.process.steps.length === 1) {
       // todo: do better to handle error generating steps
-      return Promise.reject(new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR, 'Please check your network and try again'));
+      return Promise.reject(new _TransactionError.TransactionError(_types3.BasicTxErrorType.INTERNAL_ERROR, 'Please check your network and try again'));
     }
-    console.log('handling swap process: ', params.process);
     if (handler) {
       return handler.handleSwapProcess(params);
     } else {
-      return Promise.reject(new _TransactionError.TransactionError(_types2.BasicTxErrorType.INTERNAL_ERROR));
+      return Promise.reject(new _TransactionError.TransactionError(_types3.BasicTxErrorType.INTERNAL_ERROR));
     }
   }
   subscribeSwapPairs(callback) {