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

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

@@ -1,444 +0,0 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.HydradxHandler = void 0;
-var _sdk = require("@galacticcouncil/sdk");
-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 _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
-var _xcm = require("@subwallet/extension-base/koni/api/xcm");
-var _utils = require("@subwallet/extension-base/services/chain-service/utils");
-var _baseHandler = require("@subwallet/extension-base/services/swap-service/handler/base-handler");
-var _utils2 = require("@subwallet/extension-base/services/swap-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 HYDRADX_LOW_LIQUIDITY_THRESHOLD = 0.15;
-const HYDRADX_SUBWALLET_REFERRAL_CODE = 'WALLET';
-const HYDRADX_SUBWALLET_REFERRAL_ACCOUNT = '7PCsCpkgsHdNaZhv79wCCQ5z97uxVbSeSCtDMUa1eZHKXy4a';
-const HYDRADX_TESTNET_SUBWALLET_REFERRAL_CODE = 'ASSETHUB';
-const HYDRADX_TESTNET_SUBWALLET_REFERRAL_ACCOUNT = '7LCt6dFqtxzdKVB2648jWW9d85doiFfLSbZJDNAMVJNxh5rJ';
-class HydradxHandler {
-  isReady = false;
-  constructor(chainService, balanceService) {
-    let isTestnet = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    // todo: pass in baseHandler from service
-    this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
-      balanceService,
-      chainService,
-      providerName: isTestnet ? 'HydraDX Testnet' : 'HydraDX',
-      providerSlug: isTestnet ? _swap.SwapProviderId.HYDRADX_TESTNET : _swap.SwapProviderId.HYDRADX_MAINNET
-    });
-    this.isTestnet = isTestnet;
-  }
-  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;
-    const poolService = new _sdk.PoolService(substrateApi.api);
-    this.tradeRouter = new _sdk.TradeRouter(poolService);
-    this.isReady = true;
-  }
-  get chain() {
-    // TODO: check origin chain of tokens in swap pair to determine support
-    if (!this.isTestnet) {
-      return _chainList.COMMON_CHAIN_SLUGS.HYDRADX;
-    } else {
-      return _chainList.COMMON_CHAIN_SLUGS.HYDRADX_TESTNET;
-    }
-  }
-  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 getXcmStep(params) {
-    const bnAmount = new _bignumber.default(params.request.fromAmount);
-    const fromAsset = this.chainService.getAssetBySlug(params.request.pair.from);
-    const fromAssetBalance = await this.balanceService.getTokenFreeBalance(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.getTokenFreeBalance(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: _swap.SwapStepType.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: _swap.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 getFeeOptionStep(params) {
-    return Promise.resolve(undefined);
-  }
-  async getSubmitStep(params) {
-    if (params.selectedQuote) {
-      const submitStep = {
-        name: 'Swap',
-        type: _swap.SwapStepType.SWAP
-      };
-      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
-    }
-    return Promise.resolve(undefined);
-  }
-  generateOptimalProcess(params) {
-    return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep, this.getFeeOptionStep, this.getSubmitStep]);
-  }
-  getSwapPathErrors(swapList) {
-    return swapList.reduce((prev, current) => {
-      return [...prev, ...current.errors];
-    }, []);
-  }
-  parseSwapPath(swapList) {
-    const swapAssets = this.chainService.getAssetByChainAndType(this.chain, [_types._AssetType.NATIVE, _types._AssetType.LOCAL]);
-    const swapAssetIdMap = Object.values(swapAssets).reduce((accumulator, asset) => {
-      return {
-        ...accumulator,
-        [(0, _utils._getTokenOnChainAssetId)(asset)]: asset
-      };
-    }, {});
-    const path = [];
-    swapList.forEach(swap => {
-      var _swapAssetIdMap$swap$, _swapAssetIdMap$swap$2;
-      const swapAssetIn = (_swapAssetIdMap$swap$ = swapAssetIdMap[swap.assetIn]) === null || _swapAssetIdMap$swap$ === void 0 ? void 0 : _swapAssetIdMap$swap$.slug;
-      const swapAssetOut = (_swapAssetIdMap$swap$2 = swapAssetIdMap[swap.assetOut]) === null || _swapAssetIdMap$swap$2 === void 0 ? void 0 : _swapAssetIdMap$swap$2.slug;
-      if (swapAssetIn && !path.includes(swapAssetIn)) {
-        path.push(swapAssetIn);
-      }
-      if (swapAssetOut && !path.includes(swapAssetOut)) {
-        path.push(swapAssetOut);
-      }
-    });
-    return {
-      path
-    };
-  }
-  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.tradeRouter) {
-      return new _SwapError.SwapError(_swap.SwapErrorType.UNKNOWN);
-    }
-    const earlyValidation = await this.validateSwapRequest(request);
-    if (earlyValidation.error) {
-      const metadata = earlyValidation.metadata;
-      return (0, _utils2.getEarlyHydradxValidationError)(earlyValidation.error, metadata);
-    }
-    try {
-      const fromAssetId = (0, _utils._getTokenOnChainAssetId)(fromAsset);
-      const toAssetId = (0, _utils._getTokenOnChainAssetId)(toAsset);
-      const parsedFromAmount = new _bignumber.default(request.fromAmount).shiftedBy(-1 * (0, _utils._getAssetDecimals)(fromAsset)).toString();
-      const quoteResponse = await this.tradeRouter.getBestSell(fromAssetId, toAssetId, parsedFromAmount);
-      const toAmount = quoteResponse.amountOut;
-      const minReceive = toAmount.times(1 - request.slippage).integerValue();
-      const txHex = quoteResponse.toTx(minReceive).hex;
-      const substrateApi = this.chainService.getSubstrateApi(this.chain);
-      const extrinsic = substrateApi.api.tx(txHex);
-      const paymentInfo = await extrinsic.paymentInfo(request.address);
-      const networkFee = {
-        tokenSlug: fromChainNativeTokenSlug,
-        amount: paymentInfo.partialFee.toString(),
-        feeType: _swap.SwapFeeType.NETWORK_FEE
-      };
-      const tradeFee = {
-        tokenSlug: toAsset.slug,
-        // fee is subtracted from receiving amount
-        amount: quoteResponse.tradeFee.toString(),
-        feeType: _swap.SwapFeeType.PLATFORM_FEE
-      };
-      const swapRoute = this.parseSwapPath(quoteResponse.swaps);
-      const swapPathErrors = this.getSwapPathErrors(quoteResponse.swaps);
-      if (swapPathErrors.length > 0) {
-        const defaultError = swapPathErrors[0]; // might parse more errors
-
-        switch (defaultError) {
-          case _sdk.PoolError.InsufficientTradingAmount:
-            return new _SwapError.SwapError(_swap.SwapErrorType.SWAP_NOT_ENOUGH_BALANCE);
-          case _sdk.PoolError.TradeNotAllowed:
-            return new _SwapError.SwapError(_swap.SwapErrorType.ERROR_FETCHING_QUOTE);
-          case _sdk.PoolError.MaxInRatioExceeded:
-            return new _SwapError.SwapError(_swap.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
-          case _sdk.PoolError.UnknownError:
-            return new _SwapError.SwapError(_swap.SwapErrorType.ERROR_FETCHING_QUOTE);
-          case _sdk.PoolError.MaxOutRatioExceeded:
-            return new _SwapError.SwapError(_swap.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
-        }
-      }
-      return {
-        pair: request.pair,
-        fromAmount: request.fromAmount,
-        toAmount: toAmount.toString(),
-        rate: (0, _utils2.calculateSwapRate)(request.fromAmount, toAmount.toString(), fromAsset, toAsset),
-        provider: this.providerInfo,
-        aliveUntil: +Date.now() + (_utils2.SWAP_QUOTE_TIMEOUT_MAP[this.slug] || _utils2.SWAP_QUOTE_TIMEOUT_MAP.default),
-        feeInfo: {
-          feeComponent: [networkFee, tradeFee],
-          defaultFeeToken: fromChainNativeTokenSlug,
-          feeOptions: [fromChainNativeTokenSlug] // todo: parse fee options
-        },
-
-        isLowLiquidity: Math.abs(quoteResponse.priceImpactPct) >= HYDRADX_LOW_LIQUIDITY_THRESHOLD,
-        route: swapRoute,
-        metadata: txHex
-      };
-    } catch (e) {
-      return new _SwapError.SwapError(_swap.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.getTokenFreeBalance(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) {
-    const txHex = params.quote.metadata;
-    const fromAsset = this.chainService.getAssetBySlug(params.quote.pair.from);
-    const substrateApi = this.chainService.getSubstrateApi(this.chain);
-    const chainApi = await substrateApi.isReady;
-    const txData = {
-      provider: this.providerInfo,
-      quote: params.quote,
-      address: params.address,
-      slippage: params.slippage,
-      txHex,
-      process: params.process
-    };
-    let extrinsic;
-    const _referral = await chainApi.api.query.referrals.linkedAccounts(params.address);
-    const referral = _referral === null || _referral === void 0 ? void 0 : _referral.toString();
-    if (!referral || referral === '') {
-      extrinsic = chainApi.api.tx.utility.batchAll([chainApi.api.tx.referrals.linkCode(this.referralCode), chainApi.api.tx(txHex)]);
-    } else {
-      extrinsic = chainApi.api.tx(txHex);
-    }
-    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 _swap.SwapStepType.DEFAULT:
-        return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
-      case _swap.SwapStepType.XCM:
-        return this.handleXcmStep(params);
-      case _swap.SwapStepType.SET_FEE_TOKEN:
-        return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
-      case _swap.SwapStepType.SWAP:
-        return this.handleSubmitStep(params);
-      default:
-        return this.handleSubmitStep(params);
-    }
-  }
-  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 _swap.SwapStepType.DEFAULT:
-            return Promise.resolve([]);
-          case _swap.SwapStepType.XCM:
-            return this.swapBaseHandler.validateXcmStep(params, index);
-          case _swap.SwapStepType.SET_FEE_TOKEN:
-            return this.swapBaseHandler.validateSetFeeTokenStep(params, index);
-          default:
-            return this.swapBaseHandler.validateSwapStep(params, isXcmOk, index);
-        }
-      };
-      const errors = await getErrors();
-      if (errors.length) {
-        return errors;
-      } else if (step.type === _swap.SwapStepType.XCM) {
-        isXcmOk = true;
-      }
-    }
-    return [];
-  }
-  async validateSwapRequest(request) {
-    const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
-    const toAsset = this.chainService.getAssetBySlug(request.pair.to);
-    const fromAssetId = (0, _utils._getTokenOnChainAssetId)(fromAsset);
-    const toAssetId = (0, _utils._getTokenOnChainAssetId)(toAsset);
-    try {
-      var _this$tradeRouter, _this$tradeRouter2;
-      // todo: might need to optimize for performance, but prioritize safety for now
-      const allAssets = await ((_this$tradeRouter = this.tradeRouter) === null || _this$tradeRouter === void 0 ? void 0 : _this$tradeRouter.getAllAssets());
-      if (!allAssets) {
-        return {
-          error: _swap.SwapErrorType.UNKNOWN
-        };
-      }
-      const supportedFromAsset = allAssets.find(asset => asset.id === fromAssetId && asset.symbol === fromAsset.symbol);
-      const supportedToAsset = allAssets.find(asset => asset.id === toAssetId && asset.symbol === toAsset.symbol);
-      if (!supportedFromAsset || !supportedToAsset) {
-        return {
-          error: _swap.SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      const assetPairs = await ((_this$tradeRouter2 = this.tradeRouter) === null || _this$tradeRouter2 === void 0 ? void 0 : _this$tradeRouter2.getAssetPairs(fromAssetId));
-      if (!assetPairs) {
-        return {
-          error: _swap.SwapErrorType.UNKNOWN
-        };
-      }
-      const pairedToAsset = assetPairs.find(supportedToAsset => supportedToAsset.id === toAssetId && supportedToAsset.symbol === toAsset.symbol);
-      if (!pairedToAsset) {
-        return {
-          error: _swap.SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      if (!(fromAsset.originChain === this.chain && toAsset.originChain === this.chain)) {
-        return {
-          error: _swap.SwapErrorType.ASSET_NOT_SUPPORTED
-        };
-      }
-      if (!fromAssetId || !toAssetId) {
-        return {
-          error: _swap.SwapErrorType.UNKNOWN
-        };
-      }
-      const bnAmount = new _bignumber.default(request.fromAmount);
-      if (bnAmount.lte(0)) {
-        return {
-          error: _swap.SwapErrorType.AMOUNT_CANNOT_BE_ZERO
-        };
-      }
-      return {
-        metadata: {
-          chain: this.chainService.getChainInfoByKey(this.chain)
-        }
-      };
-    } catch (e) {
-      return {
-        error: _swap.SwapErrorType.UNKNOWN
-      };
-    }
-  }
-  get referralCode() {
-    if (this.isTestnet) {
-      return HYDRADX_TESTNET_SUBWALLET_REFERRAL_CODE;
-    }
-    return HYDRADX_SUBWALLET_REFERRAL_CODE;
-  }
-  get referralAccount() {
-    if (this.isTestnet) {
-      return HYDRADX_TESTNET_SUBWALLET_REFERRAL_ACCOUNT;
-    }
-    return HYDRADX_SUBWALLET_REFERRAL_ACCOUNT;
-  }
-}
-exports.HydradxHandler = HydradxHandler;

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

@@ -1,249 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SwapService = 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 _types = require("@subwallet/extension-base/services/base/types");
-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");
-var _swap = require("@subwallet/extension-base/types/swap");
-var _utils2 = require("@subwallet/extension-base/utils");
-var _rxjs = require("rxjs");
-// Copyright 2019-2022 @subwallet/extension-base
-// SPDX-License-Identifier: Apache-2.0
-
-class SwapService {
-  swapPairSubject = new _rxjs.BehaviorSubject([]);
-  handlers = {};
-  startPromiseHandler = (0, _utils2.createPromiseHandler)();
-  stopPromiseHandler = (0, _utils2.createPromiseHandler)();
-  status = _types.ServiceStatus.NOT_INITIALIZED;
-  constructor(state) {
-    this.state = state;
-    this.eventService = state.eventService;
-    this.chainService = state.chainService;
-  }
-  async askProvidersForQuote(request) {
-    const availableQuotes = [];
-    await Promise.all(Object.values(this.handlers).map(async handler => {
-      if (handler.init && handler.isReady === false) {
-        await handler.init();
-      }
-      const quote = await handler.getSwapQuote(request);
-      if (!(quote instanceof _SwapError.SwapError)) {
-        availableQuotes.push({
-          quote
-        });
-      } else {
-        availableQuotes.push({
-          error: quote
-        });
-      }
-    }));
-    return availableQuotes; // todo: need to propagate error for further handling
-  }
-
-  getDefaultProcess(params) {
-    const result = {
-      totalFee: [_utils.MOCK_SWAP_FEE],
-      steps: [_utils.DEFAULT_SWAP_FIRST_STEP]
-    };
-    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;
-  }
-  async generateOptimalProcess(params) {
-    if (!params.selectedQuote) {
-      return this.getDefaultProcess(params);
-    } else {
-      const providerId = params.selectedQuote.provider.id;
-      const handler = this.handlers[providerId];
-      if (handler) {
-        return handler.generateOptimalProcess(params);
-      } else {
-        return this.getDefaultProcess(params);
-      }
-    }
-  }
-  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.getLatestQuotes(request);
-    const optimalProcess = await this.generateOptimalProcess({
-      request,
-      selectedQuote: swapQuoteResponse.optimalQuote
-    });
-    return {
-      process: optimalProcess,
-      quote: swapQuoteResponse
-    };
-  }
-  async getLatestQuotes(request) {
-    request.pair.metadata = this.getSwapPairMetadata(request.pair.slug); // todo: improve this
-    const quoteAskResponses = await this.askProvidersForQuote(request);
-
-    // todo: handle error to return back to UI
-    // todo: more logic to select the best quote
-
-    const availableQuotes = quoteAskResponses.filter(quote => !quote.error).map(quote => quote.quote);
-    let quoteError;
-    let selectedQuote;
-    let aliveUntil = +Date.now() + _utils.SWAP_QUOTE_TIMEOUT_MAP.default;
-    if (availableQuotes.length === 0) {
-      const preferredErrorResp = quoteAskResponses.find(quote => {
-        return !!quote.error && ![_swap.SwapErrorType.UNKNOWN, _swap.SwapErrorType.ASSET_NOT_SUPPORTED].includes(quote.error.errorType);
-      });
-      const defaultErrorResp = quoteAskResponses.find(quote => !!quote.error);
-      quoteError = (preferredErrorResp === null || preferredErrorResp === void 0 ? void 0 : preferredErrorResp.error) || (defaultErrorResp === null || defaultErrorResp === void 0 ? void 0 : defaultErrorResp.error);
-    } else {
-      var _selectedQuote;
-      selectedQuote = availableQuotes[0];
-      aliveUntil = ((_selectedQuote = selectedQuote) === null || _selectedQuote === void 0 ? void 0 : _selectedQuote.aliveUntil) || +Date.now() + _utils.SWAP_QUOTE_TIMEOUT_MAP.default;
-    }
-    return {
-      optimalQuote: selectedQuote,
-      quotes: availableQuotes,
-      error: quoteError,
-      aliveUntil
-    };
-  }
-  initHandlers() {
-    _swap._SUPPORTED_SWAP_PROVIDERS.forEach(providerId => {
-      switch (providerId) {
-        case _swap.SwapProviderId.CHAIN_FLIP_TESTNET:
-          this.handlers[providerId] = new _chainflipHandler.ChainflipSwapHandler(this.chainService, this.state.balanceService);
-          break;
-        case _swap.SwapProviderId.CHAIN_FLIP_MAINNET:
-          this.handlers[providerId] = new _chainflipHandler.ChainflipSwapHandler(this.chainService, this.state.balanceService, false);
-          break;
-        case _swap.SwapProviderId.HYDRADX_TESTNET:
-          this.handlers[providerId] = new _hydradxHandler.HydradxHandler(this.chainService, this.state.balanceService);
-          break;
-        case _swap.SwapProviderId.HYDRADX_MAINNET:
-          this.handlers[providerId] = new _hydradxHandler.HydradxHandler(this.chainService, this.state.balanceService, false);
-          break;
-        default:
-          throw new Error('Unsupported provider');
-      }
-    });
-  }
-  async init() {
-    this.status = _types.ServiceStatus.INITIALIZING;
-    this.eventService.emit('swap.ready', true);
-    this.status = _types.ServiceStatus.INITIALIZED;
-    this.initHandlers();
-    await this.start();
-  }
-  async start() {
-    if (this.status === _types.ServiceStatus.STOPPING) {
-      await this.waitForStopped();
-    }
-    if (this.status === _types.ServiceStatus.STARTED || this.status === _types.ServiceStatus.STARTING) {
-      return this.waitForStarted();
-    }
-    this.status = _types.ServiceStatus.STARTING;
-
-    // todo: start the service jobs, subscribe data,...
-
-    this.swapPairSubject.next(this.getSwapPairs()); // todo: might need to change it online
-
-    // Update promise handler
-    this.startPromiseHandler.resolve();
-    this.stopPromiseHandler = (0, _utils2.createPromiseHandler)();
-    this.status = _types.ServiceStatus.STARTED;
-  }
-  async stop() {
-    if (this.status === _types.ServiceStatus.STARTING) {
-      await this.waitForStarted();
-    }
-    if (this.status === _types.ServiceStatus.STOPPED || this.status === _types.ServiceStatus.STOPPING) {
-      return this.waitForStopped();
-    }
-
-    // todo: unsub, persist data,...
-
-    this.stopPromiseHandler.resolve();
-    this.startPromiseHandler = (0, _utils2.createPromiseHandler)();
-    this.status = _types.ServiceStatus.STOPPED;
-  }
-  waitForStarted() {
-    return this.startPromiseHandler.promise;
-  }
-  waitForStopped() {
-    return this.stopPromiseHandler.promise;
-  }
-  getSwapPairs() {
-    return Object.entries(this.chainService.swapRefMap).map(_ref => {
-      let [slug, assetRef] = _ref;
-      const fromAsset = this.chainService.getAssetBySlug(assetRef.srcAsset);
-      return {
-        slug,
-        from: assetRef.srcAsset,
-        to: assetRef.destAsset,
-        metadata: {
-          alternativeAsset: (0, _utils.getSwapAltToken)(fromAsset)
-        }
-      };
-    });
-  }
-  getSwapPairMetadata(slug) {
-    var _this$getSwapPairs$fi;
-    return (_this$getSwapPairs$fi = this.getSwapPairs().find(pair => pair.slug === slug)) === null || _this$getSwapPairs$fi === void 0 ? void 0 : _this$getSwapPairs$fi.metadata;
-  }
-  async validateSwapProcess(params) {
-    const providerId = params.selectedQuote.provider.id;
-    const handler = this.handlers[providerId];
-    if (handler) {
-      return handler.validateSwapProcess(params);
-    } else {
-      return [new _TransactionError.TransactionError(_KoniTypes.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(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR, 'Please check your network and try again'));
-    }
-    if (handler) {
-      return handler.handleSwapProcess(params);
-    } else {
-      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
-    }
-  }
-  subscribeSwapPairs(callback) {
-    return this.chainService.subscribeSwapRefMap().subscribe(refMap => {
-      const latestData = Object.entries(refMap).map(_ref2 => {
-        let [slug, assetRef] = _ref2;
-        const fromAsset = this.chainService.getAssetBySlug(assetRef.srcAsset);
-        return {
-          slug,
-          from: assetRef.srcAsset,
-          to: assetRef.destAsset,
-          metadata: {
-            alternativeAsset: (0, _utils.getSwapAltToken)(fromAsset)
-          }
-        };
-      });
-      callback(latestData);
-    });
-  }
-}
-exports.SwapService = SwapService;