@subwallet/extension-base 1.3.10-0 → 1.3.11-0

package/background/errors/SwapError.js

@@ -47,6 +47,11 @@ const defaultErrorMap = {
   MAKE_POOL_NOT_ENOUGH_EXISTENTIAL_DEPOSIT: {
     message: detectTranslate('Insufficient liquidity to complete the swap. Lower your amount and try again'),
     code: undefined
+  },
+  NOT_MEET_MIN_EXPECTED: {
+    // TODO: update message
+    message: detectTranslate('Unable to process this swap at the moment. Try again later'),
+    code: undefined
   }
 };
 export class SwapError extends SWError {

package/cjs/background/errors/SwapError.js

@@ -53,6 +53,11 @@ const defaultErrorMap = {
   MAKE_POOL_NOT_ENOUGH_EXISTENTIAL_DEPOSIT: {
     message: (0, _utils.detectTranslate)('Insufficient liquidity to complete the swap. Lower your amount and try again'),
     code: undefined
+  },
+  NOT_MEET_MIN_EXPECTED: {
+    // TODO: update message
+    message: (0, _utils.detectTranslate)('Unable to process this swap at the moment. Try again later'),
+    code: undefined
   }
 };
 class SwapError extends _SWError.SWError {

package/cjs/core/logic-validation/swap.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", {
 exports._getChainflipEarlyValidationError = _getChainflipEarlyValidationError;
 exports._getEarlyAssetHubValidationError = _getEarlyAssetHubValidationError;
 exports._getEarlyHydradxValidationError = _getEarlyHydradxValidationError;
+exports._getSimpleSwapEarlyValidationError = _getSimpleSwapEarlyValidationError;
 exports._validateBalanceToSwap = _validateBalanceToSwap;
 exports._validateBalanceToSwapOnAssetHub = _validateBalanceToSwapOnAssetHub;
 exports._validateSwapRecipient = _validateSwapRecipient;
@@ -149,4 +150,30 @@ function _getEarlyAssetHubValidationError(error, metadata) {
     default:
       return new _SwapError.SwapError(error);
   }
+}
+function _getSimpleSwapEarlyValidationError(error, metadata) {
+  // todo: support more providers
+  switch (error) {
+    case _swap.SwapErrorType.NOT_MEET_MIN_SWAP:
+      {
+        const message = `Amount too low. Increase your amount above ${metadata.minSwap.value} ${metadata.minSwap.symbol} and try again`;
+        return new _SwapError.SwapError(error, message);
+      }
+    case _swap.SwapErrorType.SWAP_EXCEED_ALLOWANCE:
+      {
+        if (metadata.maxSwap) {
+          return new _SwapError.SwapError(error, `Amount too high. Lower your amount below ${metadata.maxSwap.value} ${metadata.maxSwap.symbol} and try again`);
+        } else {
+          return new _SwapError.SwapError(error, 'Amount too high. Lower your amount and try again');
+        }
+      }
+    case _swap.SwapErrorType.ASSET_NOT_SUPPORTED:
+      return new _SwapError.SwapError(error, 'This swap pair is not supported');
+    case _swap.SwapErrorType.UNKNOWN:
+      return new _SwapError.SwapError(error, `Undefined error. Check your Internet and ${metadata.chain.slug} connection or contact support`);
+    case _swap.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/packageInfo.js

@@ -13,6 +13,6 @@ const packageInfo = {
   name: '@subwallet/extension-base',
   path: typeof __dirname === 'string' ? __dirname : 'auto',
   type: 'cjs',
-  version: '1.3.10-0'
+  version: '1.3.11-0'
 };
 exports.packageInfo = packageInfo;

package/cjs/services/chain-service/utils/patch.js

@@ -11,7 +11,7 @@ const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev';
 const fetchFile = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'list.json' : 'preview.json';
-const ChainListVersion = '0.2.95'; // update this when build chainlist
+const ChainListVersion = '0.2.96'; // update this when build chainlist
 
 // todo: move this interface to chainlist
 

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

@@ -370,7 +370,6 @@ class ChainflipSwapHandler {
       }
     });
 
-    console.log('depositAddressResp', depositAddressResponse);
     const txData = {
       address,
       provider: this.providerInfo,

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

@@ -0,0 +1,444 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.simpleSwapApiKey = exports.SimpleSwapHandler = 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 _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _types = require("@subwallet/extension-base/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _bignumber = _interopRequireWildcard(require("bignumber.js"));
+var _smartContract = require("../../balance-service/transfer/smart-contract");
+var _token = require("../../balance-service/transfer/token");
+var _utils3 = require("../utils");
+var _baseHandler = require("./base-handler");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const apiUrl = 'https://api.simpleswap.io';
+const simpleSwapApiKey = process.env.SIMPLE_SWAP_API_KEY || '';
+exports.simpleSwapApiKey = simpleSwapApiKey;
+const toBNString = (input, decimal) => {
+  const raw = new _bignumber.BigNumber(input);
+  return raw.shiftedBy(decimal).integerValue(_bignumber.BigNumber.ROUND_CEIL).toFixed();
+};
+const fetchSwapList = async params => {
+  const swapListParams = new URLSearchParams({
+    api_key: `${simpleSwapApiKey}`,
+    fixed: 'false',
+    symbol: params.fromSymbol
+  });
+  const response = await fetch(`${apiUrl}/get_pairs?${swapListParams.toString()}`, {
+    headers: {
+      accept: 'application/json'
+    }
+  });
+  return await response.json();
+};
+const fetchRanges = async params => {
+  const rangesParams = new URLSearchParams({
+    api_key: `${simpleSwapApiKey}`,
+    fixed: 'false',
+    currency_from: params.fromSymbol,
+    currency_to: params.toSymbol
+  });
+  const response = await fetch(`${apiUrl}/get_ranges?${rangesParams.toString()}`, {
+    headers: {
+      accept: 'application/json'
+    }
+  });
+  return await response.json();
+};
+async function getEstimate(request, fromAsset, toAsset) {
+  const fromSymbol = _utils3.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[fromAsset.slug];
+  const toSymbol = _utils3.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[toAsset.slug];
+  const assetDecimals = (0, _utils._getAssetDecimals)(fromAsset);
+  if (!fromSymbol || !toSymbol) {
+    throw new _SwapError.SwapError(_types.SwapErrorType.ASSET_NOT_SUPPORTED);
+  }
+  const formatedAmount = (0, _utils2.formatNumber)(request.fromAmount, assetDecimals, s => s);
+  const params = new URLSearchParams({
+    api_key: `${simpleSwapApiKey}`,
+    fixed: 'false',
+    currency_from: fromSymbol,
+    currency_to: toSymbol,
+    amount: formatedAmount
+  });
+  try {
+    const response = await fetch(`${apiUrl}/get_estimated?${params.toString()}`, {
+      headers: {
+        accept: 'application/json'
+      }
+    });
+    if (!response.ok) {
+      throw new _SwapError.SwapError(_types.SwapErrorType.ERROR_FETCHING_QUOTE);
+    }
+    const resToAmount = await response.json();
+    const toAmount = toBNString(resToAmount, (0, _utils._getAssetDecimals)(toAsset));
+    const bnToAmount = new _bignumber.default(toAmount);
+    const walletFeeRate = 4 / 1000;
+    const toAmountBeforeFee = bnToAmount.dividedBy(new _bignumber.default(1 - walletFeeRate));
+    const walletFeeAmount = toAmountBeforeFee.multipliedBy(4).dividedBy(1000).toString();
+    return {
+      toAmount,
+      walletFeeAmount
+    };
+  } catch (err) {
+    console.error('Error:', err);
+    throw new _SwapError.SwapError(_types.SwapErrorType.ERROR_FETCHING_QUOTE);
+  }
+}
+const createSwapRequest = async params => {
+  const fromDecimals = (0, _utils._getAssetDecimals)(params.fromAsset);
+  const toDecimals = (0, _utils._getAssetDecimals)(params.toAsset);
+  const formatedAmount = (0, _utils2.formatNumber)(params.fromAmount, fromDecimals, s => s);
+  const requestBody = {
+    fixed: false,
+    currency_from: params.fromSymbol,
+    currency_to: params.toSymbol,
+    amount: formatedAmount,
+    // Convert to small number due to require of api
+    address_to: params.receiver,
+    extra_id_to: '',
+    user_refund_address: params.sender,
+    user_refund_extra_id: ''
+  };
+  const response = await fetch(`${apiUrl}/create_exchange?api_key=${simpleSwapApiKey}`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Accept: 'application/json'
+    },
+    body: JSON.stringify(requestBody)
+  });
+  const depositAddressResponse = await response.json();
+  return {
+    id: depositAddressResponse.id,
+    addressFrom: depositAddressResponse.address_from,
+    amountTo: toBNString(depositAddressResponse.amount_to, toDecimals)
+  };
+};
+class SimpleSwapHandler {
+  constructor(chainService, balanceService) {
+    this.swapBaseHandler = new _baseHandler.SwapBaseHandler({
+      chainService,
+      balanceService,
+      providerName: 'SimpleSwap',
+      providerSlug: _types.SwapProviderId.SIMPLE_SWAP
+    });
+    this.providerSlug = _types.SwapProviderId.SIMPLE_SWAP;
+  }
+  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')]);
+    }
+    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.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+          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;
+      }
+    }
+    return [];
+  }
+  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 getSwapQuote(request) {
+    try {
+      var _metadata$maxSwap;
+      const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
+      const toAsset = this.chainService.getAssetBySlug(request.pair.to);
+      if (!fromAsset || !toAsset) {
+        return new _SwapError.SwapError(_types.SwapErrorType.UNKNOWN);
+      }
+      const earlyValidation = await this.validateSwapRequest(request);
+      const metadata = earlyValidation.metadata;
+      if (earlyValidation.error) {
+        return (0, _swap._getSimpleSwapEarlyValidationError)(earlyValidation.error, metadata);
+      }
+      const {
+        toAmount,
+        walletFeeAmount
+      } = await getEstimate(request, fromAsset, toAsset);
+      const fromAmount = request.fromAmount;
+      const rate = (0, _utils3.calculateSwapRate)(request.fromAmount, toAmount, fromAsset, toAsset);
+      const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
+      const fromChainNativeTokenSlug = (0, _utils._getChainNativeTokenSlug)(fromChain);
+      const defaultFeeToken = (0, _utils._isNativeToken)(fromAsset) ? fromAsset.slug : fromChainNativeTokenSlug;
+      const chainType = (0, _utils._isChainSubstrateCompatible)(fromChain) ? _KoniTypes.ChainType.SUBSTRATE : _KoniTypes.ChainType.EVM;
+      let api;
+      if (chainType === _KoniTypes.ChainType.SUBSTRATE) {
+        api = this.chainService.getSubstrateApi(fromChain.slug);
+      } else {
+        api = this.chainService.getEvmApi(fromChain.slug);
+      }
+      const networkFeeAmount = await (0, _token.getTransferMockTxFee)(request.address, fromChain, fromAsset, api);
+      const networkFee = {
+        tokenSlug: fromChainNativeTokenSlug,
+        amount: networkFeeAmount.toString(),
+        feeType: _types.SwapFeeType.NETWORK_FEE
+      };
+      const walletFee = {
+        tokenSlug: toAsset.slug,
+        amount: walletFeeAmount,
+        feeType: _types.SwapFeeType.WALLET_FEE
+      };
+      return {
+        pair: request.pair,
+        fromAmount,
+        toAmount,
+        rate,
+        provider: this.providerInfo,
+        aliveUntil: +Date.now() + (_utils3.SWAP_QUOTE_TIMEOUT_MAP[this.slug] || _utils3.SWAP_QUOTE_TIMEOUT_MAP.default),
+        minSwap: toBNString(metadata.minSwap.value, (0, _utils._getAssetDecimals)(fromAsset)),
+        maxSwap: toBNString((_metadata$maxSwap = metadata.maxSwap) === null || _metadata$maxSwap === void 0 ? void 0 : _metadata$maxSwap.value, (0, _utils._getAssetDecimals)(fromAsset)),
+        estimatedArrivalTime: 3600,
+        isLowLiquidity: false,
+        feeInfo: {
+          feeComponent: [networkFee, walletFee],
+          defaultFeeToken,
+          feeOptions: [defaultFeeToken]
+        },
+        route: {
+          path: [fromAsset.slug, toAsset.slug]
+        }
+      };
+    } catch (e) {
+      return new _SwapError.SwapError(_types.SwapErrorType.UNKNOWN);
+    }
+  }
+  generateOptimalProcess(params) {
+    return this.swapBaseHandler.generateOptimalProcess(params, [this.getSubmitStep]);
+  }
+  async getSubmitStep(params) {
+    if (params.selectedQuote) {
+      const submitStep = {
+        name: 'Swap',
+        type: _types.SwapStepType.SWAP
+      };
+      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    }
+    return Promise.resolve(undefined);
+  }
+  async validateSwapRequest(request) {
+    try {
+      const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
+      const toAsset = this.chainService.getAssetBySlug(request.pair.to);
+      if (!fromAsset || !toAsset) {
+        return {
+          error: _types.SwapErrorType.ERROR_FETCHING_QUOTE
+        };
+      }
+      const fromSymbol = _utils3.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[fromAsset.slug];
+      const toSymbol = _utils3.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[toAsset.slug];
+      if (!fromSymbol || !toSymbol) {
+        return {
+          error: _types.SwapErrorType.ASSET_NOT_SUPPORTED
+        };
+      }
+      try {
+        const swapList = await fetchSwapList({
+          fromSymbol
+        });
+        if (!swapList.includes(toSymbol)) {
+          return {
+            error: _types.SwapErrorType.ASSET_NOT_SUPPORTED
+          };
+        }
+      } catch (err) {
+        console.error('Error:', err);
+      }
+      const ranges = await fetchRanges({
+        fromSymbol,
+        toSymbol
+      });
+      const {
+        max,
+        min
+      } = ranges;
+      const bnMin = toBNString(min, (0, _utils._getAssetDecimals)(fromAsset));
+      const bnAmount = BigInt(request.fromAmount);
+      if (bnAmount < BigInt(bnMin)) {
+        return {
+          error: _types.SwapErrorType.NOT_MEET_MIN_SWAP,
+          metadata: {
+            minSwap: {
+              value: min,
+              symbol: fromAsset.symbol
+            },
+            maxSwap: max ? {
+              value: max,
+              symbol: fromAsset.symbol
+            } : undefined,
+            chain: this.chainService.getChainInfoByKey(fromAsset.originChain)
+          }
+        };
+      }
+      if (max && bnAmount > BigInt(toBNString(max, (0, _utils._getAssetDecimals)(fromAsset)))) {
+        return {
+          error: _types.SwapErrorType.SWAP_EXCEED_ALLOWANCE,
+          metadata: {
+            minSwap: {
+              value: min,
+              symbol: fromAsset.symbol
+            },
+            maxSwap: {
+              value: max,
+              symbol: fromAsset.symbol
+            },
+            chain: this.chainService.getChainInfoByKey(fromAsset.originChain)
+          }
+        };
+      }
+      return {
+        metadata: {
+          minSwap: {
+            value: min,
+            symbol: fromAsset.symbol
+          },
+          maxSwap: max ? {
+            value: max,
+            symbol: fromAsset.symbol
+          } : undefined,
+          chain: this.chainService.getChainInfoByKey(fromAsset.originChain)
+        }
+      };
+    } catch (e) {
+      console.error(e);
+      return {
+        error: _types.SwapErrorType.UNKNOWN
+      };
+    }
+  }
+  async handleSwapProcess(params) {
+    const {
+      currentStep,
+      process
+    } = params;
+    const type = process.steps[currentStep].type;
+    switch (type) {
+      case _types.CommonStepType.DEFAULT:
+        return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+      case _types.SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+  async handleSubmitStep(params) {
+    const {
+      address,
+      quote,
+      recipient
+    } = params;
+    const pair = quote.pair;
+    const fromAsset = this.chainService.getAssetBySlug(pair.from);
+    const toAsset = this.chainService.getAssetBySlug(pair.to);
+    const chainInfo = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const toChainInfo = this.chainService.getChainInfoByKey(toAsset.originChain);
+    const chainType = (0, _utils._isChainSubstrateCompatible)(chainInfo) ? _KoniTypes.ChainType.SUBSTRATE : _KoniTypes.ChainType.EVM;
+    const sender = (0, _utils2._reformatAddressWithChain)(address, chainInfo);
+    const receiver = (0, _utils2._reformatAddressWithChain)(recipient !== null && recipient !== void 0 ? recipient : sender, toChainInfo);
+    const fromSymbol = _utils3.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[fromAsset.slug];
+    const toSymbol = _utils3.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING[toAsset.slug];
+    const {
+      fromAmount
+    } = quote;
+    const {
+      addressFrom,
+      amountTo,
+      id
+    } = await createSwapRequest({
+      fromSymbol,
+      toSymbol,
+      fromAmount,
+      fromAsset,
+      receiver,
+      sender,
+      toAsset
+    });
+
+    // Validate the amount to be swapped
+    const rate = (0, _bignumber.default)(amountTo).div((0, _bignumber.default)(quote.toAmount)).multipliedBy(100);
+    if (rate.lt(95)) {
+      throw new _SwapError.SwapError(_types.SwapErrorType.NOT_MEET_MIN_EXPECTED);
+    }
+
+    // Can modify quote.toAmount to amountTo after confirm real amount received
+
+    const txData = {
+      id: id,
+      address,
+      provider: this.providerInfo,
+      quote: params.quote,
+      slippage: params.slippage,
+      recipient: receiver,
+      process: params.process
+    };
+    let extrinsic;
+    if (chainType === _KoniTypes.ChainType.SUBSTRATE) {
+      const chainApi = this.chainService.getSubstrateApi(chainInfo.slug);
+      const substrateApi = await chainApi.isReady;
+      const [submittableExtrinsic] = await (0, _token.createTransferExtrinsic)({
+        from: address,
+        networkKey: chainInfo.slug,
+        substrateApi,
+        to: addressFrom,
+        tokenInfo: fromAsset,
+        transferAll: false,
+        value: quote.fromAmount
+      });
+      extrinsic = submittableExtrinsic;
+    } else {
+      if ((0, _utils._isNativeToken)(fromAsset)) {
+        const [transactionConfig] = await (0, _smartContract.getEVMTransactionObject)(chainInfo, address, addressFrom, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        extrinsic = transactionConfig;
+      } else {
+        const [transactionConfig] = await (0, _smartContract.getERC20TransactionObject)((0, _utils._getContractAddressOfToken)(fromAsset), chainInfo, address, addressFrom, quote.fromAmount, false, this.chainService.getEvmApi(chainInfo.slug));
+        extrinsic = transactionConfig;
+      }
+    }
+    return {
+      txChain: fromAsset.originChain,
+      txData,
+      extrinsic,
+      transferNativeAmount: (0, _utils._isNativeToken)(fromAsset) ? quote.fromAmount : '0',
+      extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
+      chainType
+    };
+  }
+}
+exports.SimpleSwapHandler = SimpleSwapHandler;

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.SwapService = void 0;
+exports._isChainSupportedByProvider = exports.SwapService = void 0;
 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");
@@ -16,9 +16,15 @@ var _serviceBase = require("@subwallet/extension-base/types/service-base");
 var _swap = require("@subwallet/extension-base/types/swap");
 var _utils2 = require("@subwallet/extension-base/utils");
 var _rxjs = require("rxjs");
+var _simpleswapHandler = require("./handler/simpleswap-handler");
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+const _isChainSupportedByProvider = (providerSlug, chain) => {
+  const supportedChains = _utils._PROVIDER_TO_SUPPORTED_PAIR_MAP[providerSlug];
+  return supportedChains ? supportedChains.includes(chain) : false;
+};
+exports._isChainSupportedByProvider = _isChainSupportedByProvider;
 class SwapService {
   swapPairSubject = new _rxjs.BehaviorSubject([]);
   handlers = {};
@@ -35,7 +41,7 @@ class SwapService {
     const swappingSrcChain = this.chainService.getAssetBySlug(request.pair.from).originChain;
     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 (!_utils._PROVIDER_TO_SUPPORTED_PAIR_MAP[handler.providerSlug].includes(swappingSrcChain)) {
+      if (!_isChainSupportedByProvider(handler.providerSlug, swappingSrcChain)) {
         return;
       }
       if (handler.init && handler.isReady === false) {
@@ -122,7 +128,10 @@ 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[0];
+      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];
       aliveUntil = ((_selectedQuote = selectedQuote) === null || _selectedQuote === void 0 ? void 0 : _selectedQuote.aliveUntil) || +Date.now() + _utils.SWAP_QUOTE_TIMEOUT_MAP.default;
     }
     return {
@@ -156,6 +165,9 @@ class SwapService {
         case _swap.SwapProviderId.ROCOCO_ASSET_HUB:
           this.handlers[providerId] = new _assetHub.AssetHubSwapHandler(this.chainService, this.state.balanceService, 'rococo_assethub');
           break;
+        case _swap.SwapProviderId.SIMPLE_SWAP:
+          this.handlers[providerId] = new _simpleswapHandler.SimpleSwapHandler(this.chainService, this.state.balanceService);
+          break;
         default:
           throw new Error('Unsupported provider');
       }

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

@@ -4,7 +4,7 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports._PROVIDER_TO_SUPPORTED_PAIR_MAP = exports.SWAP_QUOTE_TIMEOUT_MAP = exports.CHAIN_FLIP_TESTNET_EXPLORER = exports.CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING = exports.CHAIN_FLIP_MAINNET_EXPLORER = void 0;
+exports._PROVIDER_TO_SUPPORTED_PAIR_MAP = exports.SWAP_QUOTE_TIMEOUT_MAP = exports.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING = exports.SIMPLE_SWAP_EXPLORER = exports.CHAIN_FLIP_TESTNET_EXPLORER = exports.CHAIN_FLIP_SUPPORTED_TESTNET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = exports.CHAIN_FLIP_SUPPORTED_MAINNET_ASSET_MAPPING = exports.CHAIN_FLIP_MAINNET_EXPLORER = void 0;
 exports.calculateSwapRate = calculateSwapRate;
 exports.convertSwapRate = convertSwapRate;
 exports.getChainflipBroker = getChainflipBroker;
@@ -24,6 +24,8 @@ 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 SIMPLE_SWAP_EXPLORER = 'https://simpleswap.io';
+exports.SIMPLE_SWAP_EXPLORER = SIMPLE_SWAP_EXPLORER;
 const CHAIN_FLIP_SUPPORTED_MAINNET_MAPPING = {
   [_chainList.COMMON_CHAIN_SLUGS.POLKADOT]: _swap.Chains.Polkadot,
   [_chainList.COMMON_CHAIN_SLUGS.ETHEREUM]: _swap.Chains.Ethereum,
@@ -48,6 +50,14 @@ const CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = {
   [_chainList.COMMON_ASSETS.USDC_SEPOLIA]: _swap.Assets.USDC
 };
 exports.CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING = CHAIN_FLIP_SUPPORTED_TESTNET_ASSET_MAPPING;
+const SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING = {
+  'bittensor-NATIVE-TAO': 'tao',
+  [_chainList.COMMON_ASSETS.ETH]: 'eth',
+  [_chainList.COMMON_ASSETS.DOT]: 'dot',
+  [_chainList.COMMON_ASSETS.USDC_ETHEREUM]: 'usdc',
+  [_chainList.COMMON_ASSETS.USDT_ETHEREUM]: 'usdterc20'
+};
+exports.SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING = SIMPLE_SWAP_SUPPORTED_TESTNET_ASSET_MAPPING;
 const SWAP_QUOTE_TIMEOUT_MAP = {
   // in milliseconds
   default: 30000,
@@ -62,7 +72,8 @@ const _PROVIDER_TO_SUPPORTED_PAIR_MAP = {
   [_swap2.SwapProviderId.CHAIN_FLIP_TESTNET]: [_chainList.COMMON_CHAIN_SLUGS.CHAINFLIP_POLKADOT, _chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA],
   [_swap2.SwapProviderId.POLKADOT_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.POLKADOT_ASSET_HUB],
   [_swap2.SwapProviderId.KUSAMA_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.KUSAMA_ASSET_HUB],
-  [_swap2.SwapProviderId.ROCOCO_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.ROCOCO_ASSET_HUB]
+  [_swap2.SwapProviderId.ROCOCO_ASSET_HUB]: [_chainList.COMMON_CHAIN_SLUGS.ROCOCO_ASSET_HUB],
+  [_swap2.SwapProviderId.SIMPLE_SWAP]: ['bittensor', _chainList.COMMON_CHAIN_SLUGS.ETHEREUM, _chainList.COMMON_CHAIN_SLUGS.POLKADOT]
 };
 exports._PROVIDER_TO_SUPPORTED_PAIR_MAP = _PROVIDER_TO_SUPPORTED_PAIR_MAP;
 function getSwapAlternativeAsset(swapPair) {

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

@@ -1063,7 +1063,7 @@ class TransactionService {
     }
     return emitter;
   }
-  async signAndSendSubstrateTransaction(_ref10) {
+  signAndSendSubstrateTransaction(_ref10) {
     let {
       address,
       chain,
@@ -1079,8 +1079,9 @@ class TransactionService {
       extrinsicHash: id
     };
     const extrinsic = transaction;
-    const registry = extrinsic.registry;
-    const signedExtensions = registry.signedExtensions;
+    // const registry = extrinsic.registry;
+    // const signedExtensions = registry.signedExtensions;
+
     const signerOption = {
       signer: {
         signPayload: async payload => {
@@ -1097,13 +1098,16 @@ class TransactionService {
       },
       withSignedTransaction: true
     };
-    if ((0, _utils4._isRuntimeUpdated)(signedExtensions)) {
-      const metadataHash = await this.state.chainService.calculateMetadataHash(chain);
-      if (metadataHash) {
-        signerOption.mode = 1;
-        signerOption.metadataHash = metadataHash;
-      }
-    }
+
+    // if (_isRuntimeUpdated(signedExtensions)) {
+    //   const metadataHash = await this.state.chainService.calculateMetadataHash(chain);
+    //
+    //   if (metadataHash) {
+    //     signerOption.mode = 1;
+    //     signerOption.metadataHash = metadataHash;
+    //   }
+    // }
+
     extrinsic.signAsync(address, signerOption).then(async rs => {
       // Emit signed event
       emitter.emit('signed', eventData);