@subwallet/extension-base 1.1.54-0 → 1.1.56-0

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

@@ -0,0 +1,250 @@
+"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
+    });
+    console.log('optimalProcess', optimalProcess);
+    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;

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

@@ -0,0 +1,126 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SWAP_QUOTE_TIMEOUT_MAP = exports.MOCK_SWAP_FEE = exports.DEFAULT_SWAP_FIRST_STEP = 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.getChainflipEarlyValidationError = getChainflipEarlyValidationError;
+exports.getEarlyHydradxValidationError = getEarlyHydradxValidationError;
+exports.getSwapAltToken = getSwapAltToken;
+exports.getSwapAlternativeAsset = getSwapAlternativeAsset;
+var _swap = require("@chainflip/sdk/swap");
+var _chainList = require("@subwallet/chain-list");
+var _SwapError = require("@subwallet/extension-base/background/errors/SwapError");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _swap2 = require("@subwallet/extension-base/types/swap");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const CHAIN_FLIP_TESTNET_EXPLORER = 'https://blocks-perseverance.chainflip.io';
+exports.CHAIN_FLIP_TESTNET_EXPLORER = CHAIN_FLIP_TESTNET_EXPLORER;
+const CHAIN_FLIP_MAINNET_EXPLORER = 'https://scan.chainflip.io';
+exports.CHAIN_FLIP_MAINNET_EXPLORER = CHAIN_FLIP_MAINNET_EXPLORER;
+const CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = {
+  [_chainList.COMMON_CHAIN_SLUGS.POLKADOT]: _swap.Chains.Polkadot,
+  [_chainList.COMMON_CHAIN_SLUGS.ETHEREUM]: _swap.Chains.Ethereum
+};
+exports.CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING;
+const CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING = {
+  [_chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA]: _swap.Chains.Ethereum,
+  [_chainList.COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT]: _swap.Chains.Polkadot
+};
+exports.CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING = CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING;
+const CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING = {
+  [_chainList.COMMON_ASSETS.DOT]: _swap.Assets.DOT,
+  [_chainList.COMMON_ASSETS.ETH]: _swap.Assets.ETH,
+  [_chainList.COMMON_ASSETS.USDC_ETHEREUM]: _swap.Assets.USDC
+};
+exports.CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING = CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING;
+const CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = {
+  [_chainList.COMMON_ASSETS.PDOT]: _swap.Assets.DOT,
+  [_chainList.COMMON_ASSETS.ETH_SEPOLIA]: _swap.Assets.ETH,
+  [_chainList.COMMON_ASSETS.USDC_SEPOLIA]: _swap.Assets.USDC
+};
+exports.CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING;
+const SWAP_QUOTE_TIMEOUT_MAP = {
+  // in milliseconds
+  default: 30000,
+  [_swap2.SwapProviderId.CHAIN_FLIP_TESTNET]: 30000,
+  [_swap2.SwapProviderId.CHAIN_FLIP_MAINNET]: 30000
+};
+exports.SWAP_QUOTE_TIMEOUT_MAP = SWAP_QUOTE_TIMEOUT_MAP;
+const DEFAULT_SWAP_FIRST_STEP = {
+  id: 0,
+  name: 'Fill information',
+  type: _swap2.SwapStepType.DEFAULT
+};
+exports.DEFAULT_SWAP_FIRST_STEP = DEFAULT_SWAP_FIRST_STEP;
+const MOCK_SWAP_FEE = {
+  feeComponent: [],
+  defaultFeeToken: '',
+  feeOptions: []
+};
+exports.MOCK_SWAP_FEE = MOCK_SWAP_FEE;
+function getSwapAlternativeAsset(swapPair) {
+  var _swapPair$metadata;
+  return swapPair === null || swapPair === void 0 ? void 0 : (_swapPair$metadata = swapPair.metadata) === null || _swapPair$metadata === void 0 ? void 0 : _swapPair$metadata.alternativeAsset;
+}
+function getSwapAltToken(chainAsset) {
+  var _chainAsset$metadata;
+  return (_chainAsset$metadata = chainAsset.metadata) === null || _chainAsset$metadata === void 0 ? void 0 : _chainAsset$metadata.alternativeSwapAsset;
+}
+function calculateSwapRate(fromAmount, toAmount, fromAsset, toAsset) {
+  const bnFromAmount = new _bignumber.default(fromAmount);
+  const bnToAmount = new _bignumber.default(toAmount);
+  const decimalDiff = (0, _utils._getAssetDecimals)(toAsset) - (0, _utils._getAssetDecimals)(fromAsset);
+  const bnRate = bnFromAmount.div(bnToAmount);
+  return 1 / bnRate.times(10 ** decimalDiff).toNumber();
+}
+function getChainflipEarlyValidationError(error, metadata) {
+  // todo: support more providers
+  switch (error) {
+    case _swap2.SwapErrorType.NOT_MEET_MIN_SWAP:
+      {
+        const parsedMinSwapValue = (0, _utils2.formatNumber)(metadata.minSwap.value, metadata.minSwap.decimals);
+        const message = `Amount too low. Increase your amount above ${parsedMinSwapValue} ${metadata.minSwap.symbol} and try again`;
+        return new _SwapError.SwapError(error, message);
+      }
+    case _swap2.SwapErrorType.SWAP_EXCEED_ALLOWANCE:
+      {
+        if (metadata.maxSwap) {
+          const parsedMaxSwapValue = (0, _utils2.formatNumber)(metadata.maxSwap.value, metadata.maxSwap.decimals);
+          return new _SwapError.SwapError(error, `Amount too high. Lower your amount below ${parsedMaxSwapValue} ${metadata.maxSwap.symbol} and try again`);
+        } else {
+          return new _SwapError.SwapError(error, 'Amount too high. Lower your amount and try again');
+        }
+      }
+    case _swap2.SwapErrorType.ASSET_NOT_SUPPORTED:
+      return new _SwapError.SwapError(error, 'This swap pair is not supported');
+    case _swap2.SwapErrorType.UNKNOWN:
+      return new _SwapError.SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
+    case _swap2.SwapErrorType.ERROR_FETCHING_QUOTE:
+      return new _SwapError.SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
+    default:
+      return new _SwapError.SwapError(error);
+  }
+}
+function getEarlyHydradxValidationError(error, metadata) {
+  switch (error) {
+    case _swap2.SwapErrorType.AMOUNT_CANNOT_BE_ZERO:
+      {
+        return new _SwapError.SwapError(error, 'Amount too low. Increase your amount above 0 and try again');
+      }
+    case _swap2.SwapErrorType.ASSET_NOT_SUPPORTED:
+      return new _SwapError.SwapError(error, 'This swap pair is not supported');
+    case _swap2.SwapErrorType.UNKNOWN:
+      return new _SwapError.SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
+    case _swap2.SwapErrorType.ERROR_FETCHING_QUOTE:
+      return new _SwapError.SwapError(error, 'No swap quote found. Adjust your amount or try again later.');
+    default:
+      return new _SwapError.SwapError(error);
+  }
+}

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

@@ -646,6 +646,18 @@ class TransactionService {
           };
           break;
         }
+      case _KoniTypes.ExtrinsicType.SWAP:
+        {
+          const data = (0, _utils3.parseTransactionData)(transaction.data); // TODO: switch by provider
+          const inputAsset = this.state.chainService.getAssetBySlug(data.quote.pair.from);
+          historyItem.amount = {
+            value: data.quote.fromAmount,
+            symbol: (0, _utils._getAssetSymbol)(inputAsset),
+            decimals: (0, _utils._getAssetDecimals)(inputAsset)
+          };
+          historyItem.additionalInfo = data;
+          break;
+        }
       case _KoniTypes.ExtrinsicType.UNKNOWN:
         break;
     }
@@ -742,6 +754,14 @@ class TransactionService {
       }
     } else if ([_KoniTypes.ExtrinsicType.STAKING_BOND, _KoniTypes.ExtrinsicType.STAKING_UNBOND, _KoniTypes.ExtrinsicType.STAKING_WITHDRAW, _KoniTypes.ExtrinsicType.STAKING_CANCEL_UNSTAKE, _KoniTypes.ExtrinsicType.STAKING_CLAIM_REWARD, _KoniTypes.ExtrinsicType.STAKING_JOIN_POOL, _KoniTypes.ExtrinsicType.STAKING_POOL_WITHDRAW, _KoniTypes.ExtrinsicType.STAKING_LEAVE_POOL].includes(transaction.extrinsicType)) {
       this.state.eventService.emit('transaction.submitStaking', transaction.chain);
+    } else if (transaction.extrinsicType === _KoniTypes.ExtrinsicType.SWAP) {
+      const inputData = (0, _utils3.parseTransactionData)(transaction.data);
+      const toAssetSlug = inputData.quote.pair.to;
+
+      // todo: consider async
+      this.state.chainService.updateAssetSetting(toAssetSlug, {
+        visible: true
+      }, true).catch(console.error);
     }
   }
   onSuccess(_ref4) {

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

@@ -3,9 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.getChainflipExplorerLink = getChainflipExplorerLink;
 exports.getExplorerLink = getExplorerLink;
 exports.parseTransactionData = parseTransactionData;
 var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/services/swap-service/utils");
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
@@ -53,4 +55,8 @@ function getExplorerLink(chainInfo, value, type) {
     return `${explorerLink}${explorerLink.endsWith('/') ? '' : '/'}${route}/${value}`;
   }
   return undefined;
+}
+function getChainflipExplorerLink(data, chainInfo) {
+  const chainflipDomain = (0, _utils._isChainTestNet)(chainInfo) ? _utils2.CHAIN_FLIP_TESTNET_EXPLORER : _utils2.CHAIN_FLIP_MAINNET_EXPLORER;
+  return `${chainflipDomain}/channels/${data.depositChannelId}`;
 }

package/cjs/types/fee/evm.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/types/fee/fee.js

@@ -0,0 +1,70 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SWFeeType = exports.SWFee = void 0;
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+let SWFeeType;
+exports.SWFeeType = SWFeeType;
+(function (SWFeeType) {
+  SWFeeType["EIP_1559"] = "EIP_1559";
+  SWFeeType["LEGACY"] = "LEGACY";
+  SWFeeType["SUBSTRATE"] = "SUBSTRATE";
+})(SWFeeType || (exports.SWFeeType = SWFeeType = {}));
+class SWFee {
+  get transactionId() {
+    return this._transactionId;
+  }
+  get selectedFeeOption() {
+    return this._selectedFeeOption;
+  }
+  static build(feeOptions, chain, selectedFeeOption) {
+    // todo: might need to parse metadata depending on the type
+    if (selectedFeeOption) {
+      return new SWFee(feeOptions, chain, selectedFeeOption);
+    } else {
+      const defaultFeeOption = feeOptions.find(option => option.isDefault);
+      return new SWFee(feeOptions, chain, defaultFeeOption);
+    }
+  }
+  static buildSimpleFee(tokenInfo, amount, type) {
+    // used for simple transaction paid in native tokens
+    const defaultOption = {
+      tokenInfo,
+      isDefault: (0, _utils._isNativeToken)(tokenInfo),
+      // if it's the native token of the chain
+      amount,
+      type
+    };
+    return new SWFee([defaultOption], tokenInfo.originChain, defaultOption);
+  }
+  static buildFeeOption(tokenInfo, amount, type) {
+    // todo: calculate totalFeeValue
+    // todo: implement more logic to handle complicated transaction process
+    return {
+      tokenInfo,
+      isDefault: (0, _utils._isNativeToken)(tokenInfo),
+      // if it's the native token of the chain
+      amount,
+      type
+    };
+  }
+  setTransactionId(transactionId) {
+    this._transactionId = transactionId;
+  }
+  setSelectedFeeOption(feeOption) {
+    this._selectedFeeOption = feeOption;
+  }
+  constructor(feeOptions, chain, selectedFeeOption) {
+    this.chain = chain;
+    this.feeOptions = feeOptions;
+    this._selectedFeeOption = selectedFeeOption;
+  }
+  getDefaultFeeOption() {
+    return this.feeOptions.find(option => option.isDefault);
+  }
+}
+exports.SWFee = SWFee;

package/cjs/types/fee/index.js

@@ -1 +1,27 @@
-"use strict";
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _evm = require("./evm");
+Object.keys(_evm).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _evm[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _evm[key];
+    }
+  });
+});
+var _fee = require("./fee");
+Object.keys(_fee).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _fee[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _fee[key];
+    }
+  });
+});

package/cjs/types/service-base.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/types/swap/index.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports._SUPPORTED_SWAP_PROVIDERS = exports.SwapStepType = exports.SwapProviderId = exports.SwapFeeType = exports.SwapErrorType = void 0;
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+// core
+let SwapErrorType;
+exports.SwapErrorType = SwapErrorType;
+(function (SwapErrorType) {
+  SwapErrorType["ERROR_FETCHING_QUOTE"] = "ERROR_FETCHING_QUOTE";
+  SwapErrorType["NOT_MEET_MIN_SWAP"] = "NOT_MEET_MIN_SWAP";
+  SwapErrorType["UNKNOWN"] = "UNKNOWN";
+  SwapErrorType["ASSET_NOT_SUPPORTED"] = "ASSET_NOT_SUPPORTED";
+  SwapErrorType["QUOTE_TIMEOUT"] = "QUOTE_TIMEOUT";
+  SwapErrorType["INVALID_RECIPIENT"] = "INVALID_RECIPIENT";
+  SwapErrorType["SWAP_EXCEED_ALLOWANCE"] = "SWAP_EXCEED_ALLOWANCE";
+  SwapErrorType["SWAP_NOT_ENOUGH_BALANCE"] = "SWAP_NOT_ENOUGH_BALANCE";
+  SwapErrorType["NOT_ENOUGH_LIQUIDITY"] = "NOT_ENOUGH_LIQUIDITY";
+  SwapErrorType["AMOUNT_CANNOT_BE_ZERO"] = "AMOUNT_CANNOT_BE_ZERO";
+})(SwapErrorType || (exports.SwapErrorType = SwapErrorType = {}));
+let SwapStepType;
+exports.SwapStepType = SwapStepType;
+(function (SwapStepType) {
+  SwapStepType["DEFAULT"] = "DEFAULT";
+  SwapStepType["TOKEN_APPROVAL"] = "TOKEN_APPROVAL";
+  SwapStepType["SET_FEE_TOKEN"] = "SET_FEE_TOKEN";
+  SwapStepType["SWAP"] = "SWAP";
+  SwapStepType["XCM"] = "XCM";
+})(SwapStepType || (exports.SwapStepType = SwapStepType = {}));
+let SwapProviderId;
+exports.SwapProviderId = SwapProviderId;
+(function (SwapProviderId) {
+  SwapProviderId["CHAIN_FLIP_TESTNET"] = "CHAIN_FLIP_TESTNET";
+  SwapProviderId["CHAIN_FLIP_MAINNET"] = "CHAIN_FLIP_MAINNET";
+  SwapProviderId["HYDRADX_MAINNET"] = "HYDRADX_MAINNET";
+  SwapProviderId["HYDRADX_TESTNET"] = "HYDRADX_TESTNET";
+})(SwapProviderId || (exports.SwapProviderId = SwapProviderId = {}));
+const _SUPPORTED_SWAP_PROVIDERS = [SwapProviderId.CHAIN_FLIP_TESTNET, SwapProviderId.CHAIN_FLIP_MAINNET, SwapProviderId.HYDRADX_MAINNET, SwapProviderId.HYDRADX_TESTNET];
+exports._SUPPORTED_SWAP_PROVIDERS = _SUPPORTED_SWAP_PROVIDERS;
+// process handling
+let SwapFeeType;
+exports.SwapFeeType = SwapFeeType;
+(function (SwapFeeType) {
+  SwapFeeType["PLATFORM_FEE"] = "PLATFORM_FEE";
+  SwapFeeType["NETWORK_FEE"] = "NETWORK_FEE";
+  SwapFeeType["WALLET_FEE"] = "WALLET_FEE";
+})(SwapFeeType || (exports.SwapFeeType = SwapFeeType = {}));

package/cjs/utils/index.js

@@ -236,6 +236,18 @@ Object.keys(_fetchEvmChainInfo).forEach(function (key) {
     }
   });
 });
+var _swap = require("./swap");
+Object.keys(_swap).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _swap[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _swap[key];
+    }
+  });
+});
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0