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

package/cjs/koni/background/handlers/State.js

@@ -1227,34 +1227,17 @@ class KoniState {
       maxFeePerGas: autoFormatNumber(transactionParams.maxFeePerGas),
       data: transactionParams.data
     };
-    const getTransactionGas = async () => {
-      try {
-        transaction.gas = await web3.eth.estimateGas({
-          ...transaction
-        });
-      } catch (e) {
-        // @ts-ignore
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.INVALID_PARAMS, e === null || e === void 0 ? void 0 : e.message);
-      }
-    };
 
     // Calculate transaction data
     try {
-      await Promise.race([getTransactionGas(), (0, _utils3.wait)(3000).then(async () => {
-        if (!transaction.gas) {
-          await this.chainService.initSingleApi(networkKey);
-          await getTransactionGas();
-        }
-      })]);
+      transaction.gas = await web3.eth.estimateGas({
+        ...transaction
+      });
     } catch (e) {
       // @ts-ignore
       // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
       throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.INVALID_PARAMS, e === null || e === void 0 ? void 0 : e.message);
     }
-    if (!transaction.gas) {
-      throw new _EvmProviderError.EvmProviderError(_KoniTypes.EvmProviderErrorType.INVALID_PARAMS);
-    }
     let estimateGas;
 
     // TODO: Review, If not override, transaction maybe fail because fee too low

package/cjs/packageInfo.js

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

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

@@ -631,15 +631,6 @@ class ChainService {
       }
     }));
   }
-  async initSingleApi(slug) {
-    const chainInfoMap = this.getChainInfoMap();
-    const chainStateMap = this.getChainStateMap();
-    if (!chainStateMap[slug].active) {
-      return false;
-    }
-    await this.initApiForChain(chainInfoMap[slug]);
-    return true;
-  }
   async initApiForChain(chainInfo) {
     const {
       endpoint,
@@ -1658,5 +1649,10 @@ class ChainService {
     }
     return result;
   }
+  getFeeTokensByChain(chainSlug) {
+    return Object.values(this.getAssetRegistry()).filter(chainAsset => {
+      return chainAsset.originChain === chainSlug && (chainAsset.assetType === _types._AssetType.NATIVE || (0, _utils._isAssetCanPayTxFee)(chainAsset));
+    }).map(chainAsset => chainAsset.slug);
+  }
 }
 exports.ChainService = ChainService;

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

@@ -74,6 +74,7 @@ var _exportNames = {
   findChainInfoByChainId: true,
   _isMantaZkAsset: true,
   randomizeProvider: true,
+  _isAssetCanPayTxFee: true,
   updateLatestChainInfo: true
 };
 exports._checkSmartContractSupportByChain = _checkSmartContractSupportByChain;
@@ -110,6 +111,7 @@ exports._getXcmAssetMultilocation = _getXcmAssetMultilocation;
 exports._getXcmAssetType = _getXcmAssetType;
 exports._getXcmTransferType = _getXcmTransferType;
 exports._isAssetAutoEnable = void 0;
+exports._isAssetCanPayTxFee = _isAssetCanPayTxFee;
 exports._isAssetFungibleToken = _isAssetFungibleToken;
 exports._isAssetSmartContractNft = _isAssetSmartContractNft;
 exports._isAssetValuable = _isAssetValuable;
@@ -562,6 +564,10 @@ function randomizeProvider(providers, excludedKeys) {
     providerValue: selectedProviderValue
   };
 }
+function _isAssetCanPayTxFee(chainAsset) {
+  var _ref, _chainAsset$metadata;
+  return (_ref = (_chainAsset$metadata = chainAsset.metadata) === null || _chainAsset$metadata === void 0 ? void 0 : _chainAsset$metadata.canPayTxFee) !== null && _ref !== void 0 ? _ref : false;
+}
 function updateLatestChainInfo(currentDataMap, latestChainInfoList) {
   const currentChainInfoMap = currentDataMap.chainInfoMap;
   const currentChainStateMap = currentDataMap.chainStateMap;
@@ -574,8 +580,8 @@ function updateLatestChainInfo(currentDataMap, latestChainInfoList) {
     let needUpdate = false;
     if (currentChainInfo && currentChainState) {
       const preservedProvider = {};
-      Object.entries(currentChainInfo.providers).forEach(_ref => {
-        let [providerKey, providerValue] = _ref;
+      Object.entries(currentChainInfo.providers).forEach(_ref2 => {
+        let [providerKey, providerValue] = _ref2;
         if (providerValue !== null && providerValue !== void 0 && providerValue.startsWith('light') || providerKey !== null && providerKey !== void 0 && providerKey.startsWith(_types2._CUSTOM_PREFIX)) {
           preservedProvider[providerKey] = providerValue;
         }

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

@@ -12,7 +12,7 @@ var _crossFetch = _interopRequireDefault(require("cross-fetch"));
 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 ChainListVersion = '0.2.55-beta.3';
+const ChainListVersion = '0.2.55';
 async function fetchPatchData(slug) {
   try {
     const fetchPromise = (0, _crossFetch.default)(`${fetchDomain}/patch/${ChainListVersion}/${slug}`);

package/cjs/services/migration-service/scripts/MigrateTransactionHistoryBySymbol.js

@@ -14,23 +14,10 @@ class MigrateTransactionHistoryBySymbol extends _Base.default {
     const state = this.state;
     try {
       const changeSlugsMap = {
-        'ethereum-ERC20-WFTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870': 'ethereum-ERC20-FTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870',
-        'moonbeam-ERC20-CSG-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F': 'moonbeam-ERC20-CGS-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F',
-        'astar-LOCAL-aUSD': 'astar-LOCAL-aSEED',
-        'astarEvm-ERC20-aUSD-0xfFFFFfFF00000000000000010000000000000001': 'astarEvm-ERC20-aSEED-0xfFFFFfFF00000000000000010000000000000001',
-        'moonriver-LOCAL-xcaUSD': 'moonriver-LOCAL-xcaSeed',
-        'moonriver-LOCAL-xckBTC': 'moonriver-LOCAL-xcKBTC',
-        'bifrost-LOCAL-aUSD': 'bifrost-LOCAL-KUSD',
-        'calamari-LOCAL-aUSD': 'calamari-LOCAL-AUSD',
-        'shiden-LOCAL-aUSD': 'shiden-LOCAL-aSEED',
-        'shidenEvm-ERC20-aUSD-0xfFFfFFfF00000000000000010000000000000000': 'shidenEvm-ERC20-aSEED-0xfFFfFFfF00000000000000010000000000000000',
-        'ethereum_goerli-NATIVE-GoerliETH': 'ethereum_goerli-NATIVE-ETH',
-        'binance_test-NATIVE-BNB': 'binance_test-NATIVE-tBNB',
-        'pangolin-LOCAL-CKTON': 'pangolin-LOCAL-PKTON',
-        'zeta_test-NATIVE-aZETA': 'zeta_test-NATIVE-ZETA',
-        'origintrail-NATIVE-OTP': 'origintrail-NATIVE-NEURO',
-        'moonbeam-LOCAL-xciBTC': 'moonbeam-LOCAL-xcIBTC',
-        'tomochain-NATIVE-TOMO': 'tomochain-NATIVE-VIC'
+        'moonbeam-LOCAL-xcaUSD': 'moonbeam-LOCAL-xcaSEED',
+        'calamari-LOCAL-AUSD': 'calamari-LOCAL-aSEED',
+        'moonriver-LOCAL-xcaSeed': 'moonriver-LOCAL-xcaSEED',
+        'bifrost-LOCAL-KUSD': 'bifrost-LOCAL-aSEED'
       };
       const allTxs = [];
       await Promise.all(Object.entries(changeSlugsMap).map(async (_ref, i) => {

package/cjs/services/migration-service/scripts/databases/MigrateAssetSetting.js

@@ -13,23 +13,10 @@ class MigrateAssetSetting extends _Base.default {
   async run() {
     try {
       const changeSlugsMap = {
-        'ethereum-ERC20-WFTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870': 'ethereum-ERC20-FTM-0x4E15361FD6b4BB609Fa63C81A2be19d873717870',
-        'moonbeam-ERC20-CSG-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F': 'moonbeam-ERC20-CGS-0x2Dfc76901bB2ac2A5fA5fc479590A490BBB10a5F',
-        'astar-LOCAL-aUSD': 'astar-LOCAL-aSEED',
-        'astarEvm-ERC20-aUSD-0xfFFFFfFF00000000000000010000000000000001': 'astarEvm-ERC20-aSEED-0xfFFFFfFF00000000000000010000000000000001',
-        'moonriver-LOCAL-xcaUSD': 'moonriver-LOCAL-xcaSeed',
-        'moonriver-LOCAL-xckBTC': 'moonriver-LOCAL-xcKBTC',
-        'bifrost-LOCAL-aUSD': 'bifrost-LOCAL-KUSD',
-        'calamari-LOCAL-aUSD': 'calamari-LOCAL-AUSD',
-        'shiden-LOCAL-aUSD': 'shiden-LOCAL-aSEED',
-        'shidenEvm-ERC20-aUSD-0xfFFfFFfF00000000000000010000000000000000': 'shidenEvm-ERC20-aSEED-0xfFFfFFfF00000000000000010000000000000000',
-        'ethereum_goerli-NATIVE-GoerliETH': 'ethereum_goerli-NATIVE-ETH',
-        'binance_test-NATIVE-BNB': 'binance_test-NATIVE-tBNB',
-        'pangolin-LOCAL-CKTON': 'pangolin-LOCAL-PKTON',
-        'zeta_test-NATIVE-aZETA': 'zeta_test-NATIVE-ZETA',
-        'origintrail-NATIVE-OTP': 'origintrail-NATIVE-NEURO',
-        'moonbeam-LOCAL-xciBTC': 'moonbeam-LOCAL-xcIBTC',
-        'tomochain-NATIVE-TOMO': 'tomochain-NATIVE-VIC'
+        'moonbeam-LOCAL-xcaUSD': 'moonbeam-LOCAL-xcaSEED',
+        'calamari-LOCAL-AUSD': 'calamari-LOCAL-aSEED',
+        'moonriver-LOCAL-xcaSeed': 'moonriver-LOCAL-xcaSEED',
+        'bifrost-LOCAL-KUSD': 'bifrost-LOCAL-aSEED'
       };
       const assetSetting = await this.state.chainService.getAssetSettings();
       const migratedAssetSetting = {};

package/cjs/services/migration-service/scripts/index.js

@@ -55,9 +55,9 @@ var _default = {
   '1.1.26-01': _MigratePolygonUSDCProvider.default,
   '1.1.28-01': _MigrateEarningVersion.default,
   '1.1.41-01': _DeleteChainStaking.default,
-  '1.1.44-01': _MigrateAssetSetting.default,
-  '1.1.45-01': _MigrateTransactionHistoryBySymbol.default,
-  '1.1.46-01': _AutoEnableSomeTokens.default
+  '1.1.46-01': _AutoEnableSomeTokens.default,
+  '1.1.53-01': _MigrateAssetSetting.default,
+  '1.1.53-02': _MigrateTransactionHistoryBySymbol.default
   // [`${EVERYTIME}-1.1.42-02`]: MigrateTransactionHistoryBySymbol
   // [`${EVERYTIME}-1`]: AutoEnableChainsTokens
 };

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

@@ -104,7 +104,19 @@ class SwapBaseHandler {
     return Promise.resolve([]);
   }
   async validateSetFeeTokenStep(params, stepIndex) {
-    return Promise.resolve([]);
+    if (!params.selectedQuote) {
+      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const feeInfo = params.process.totalFee[stepIndex];
+    const feeAmount = feeInfo.feeComponent[0];
+    const feeTokenInfo = this.chainService.getAssetBySlug(feeInfo.defaultFeeToken);
+    const feeTokenBalance = await this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug);
+    const bnFeeTokenBalance = new _bignumber.default(feeTokenBalance.value);
+    const bnFeeAmount = new _bignumber.default(feeAmount.amount);
+    if (bnFeeAmount.gte(bnFeeTokenBalance)) {
+      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE)]);
+    }
+    return [];
   }
   async validateSwapStep(params, isXcmOk, stepIndex) {
     if (!params.selectedQuote) {
@@ -127,9 +139,15 @@ class SwapBaseHandler {
     const [feeTokenBalance, fromAssetBalance] = await Promise.all([this.balanceService.getTokenFreeBalance(params.address, feeTokenInfo.originChain, feeTokenInfo.slug), this.balanceService.getTokenFreeBalance(params.address, fromAsset.originChain, fromAsset.slug)]);
     const bnFeeTokenBalance = new _bignumber.default(feeTokenBalance.value);
     const bnFromAssetBalance = new _bignumber.default(fromAssetBalance.value);
-    if (bnFeeTokenBalance.lte(new _bignumber.default(networkFee.amount))) {
+    const bnFeeAmount = new _bignumber.default(networkFee.amount);
+    if (bnFeeTokenBalance.lte(bnFeeAmount)) {
       return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, `You don't have enough ${feeTokenInfo.symbol} (${feeTokenChain.name}) to pay transaction fee`)]);
     }
+    if (fromAsset.slug === feeTokenInfo.slug) {
+      if (bnFromAssetBalance.lte(bnFeeAmount.plus(bnAmount))) {
+        return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.NOT_ENOUGH_BALANCE, `Insufficient balance. Deposit ${fromAsset.symbol} and try again.`)]);
+      }
+    }
     if (params.selectedQuote.minSwap) {
       const minProtocolSwap = new _bignumber.default(params.selectedQuote.minSwap);
       if (!isXcmOk && bnFromAssetBalance.lte(minProtocolSwap)) {

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

@@ -26,10 +26,10 @@ const HYDRADX_SUBWALLET_REFERRAL_ACCOUNT = '7PCsCpkgsHdNaZhv79wCCQ5z97uxVbSeSCtD
 const HYDRADX_TESTNET_SUBWALLET_REFERRAL_CODE = 'ASSETHUB';
 const HYDRADX_TESTNET_SUBWALLET_REFERRAL_ACCOUNT = '7LCt6dFqtxzdKVB2648jWW9d85doiFfLSbZJDNAMVJNxh5rJ';
 class HydradxHandler {
+  isTestnet = true;
   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,
@@ -39,24 +39,24 @@ class HydradxHandler {
     this.isTestnet = isTestnet;
   }
   async init() {
-    const chainState = this.chainService.getChainStateByKey(this.chain);
+    const chainState = this.chainService.getChainStateByKey(this.chain());
     if (!chainState.active) {
-      await this.chainService.enableChain(this.chain);
+      await this.chainService.enableChain(this.chain());
     }
-    const substrateApi = this.chainService.getSubstrateApi(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() {
+  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;
   }
@@ -128,7 +128,44 @@ class HydradxHandler {
     }
   }
   async getFeeOptionStep(params) {
-    return Promise.resolve(undefined);
+    if (!params.selectedQuote) {
+      return Promise.resolve(undefined);
+    }
+    const selectedFeeToken = params.selectedQuote.feeInfo.selectedFeeToken;
+    if (!selectedFeeToken) {
+      return undefined;
+    }
+    const feeStep = {
+      name: 'Set fee token',
+      type: _swap.SwapStepType.SET_FEE_TOKEN
+    };
+    try {
+      const substrateApi = this.chainService.getSubstrateApi(this.chain());
+      const chainApi = await substrateApi.isReady;
+      const _currentFeeAssetId = await chainApi.api.query.multiTransactionPayment.accountCurrencyMap(params.request.address);
+      const currentFeeAssetId = _currentFeeAssetId.toString();
+      const selectedFeeAsset = this.chainService.getAssetBySlug(selectedFeeToken);
+      const assetId = (0, _utils._getTokenOnChainAssetId)(selectedFeeAsset);
+      if (currentFeeAssetId === assetId) {
+        return;
+      }
+      const setFeeTx = chainApi.api.tx.multiTransactionPayment.setCurrency(assetId);
+      const _txFee = await setFeeTx.paymentInfo(params.request.address);
+      const txFee = _txFee.toPrimitive();
+      const fee = {
+        feeComponent: [{
+          feeType: _swap.SwapFeeType.NETWORK_FEE,
+          amount: Math.round(txFee.partialFee).toString(),
+          tokenSlug: selectedFeeAsset.slug
+        }],
+        selectedFeeToken: selectedFeeAsset.slug,
+        defaultFeeToken: selectedFeeAsset.slug,
+        feeOptions: [selectedFeeAsset.slug]
+      };
+      return [feeStep, fee];
+    } catch (e) {
+      return undefined;
+    }
   }
   async getSubmitStep(params) {
     if (params.selectedQuote) {
@@ -141,7 +178,9 @@ class HydradxHandler {
     return Promise.resolve(undefined);
   }
   generateOptimalProcess(params) {
-    return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep, this.getFeeOptionStep, this.getSubmitStep]);
+    return this.swapBaseHandler.generateOptimalProcess(params, [this.getXcmStep,
+    // this.getFeeOptionStep.bind(this),
+    this.getSubmitStep]);
   }
   getSwapPathErrors(swapList) {
     return swapList.reduce((prev, current) => {
@@ -149,7 +188,7 @@ class HydradxHandler {
     }, []);
   }
   parseSwapPath(swapList) {
-    const swapAssets = this.chainService.getAssetByChainAndType(this.chain, [_types._AssetType.NATIVE, _types._AssetType.LOCAL]);
+    const swapAssets = this.chainService.getAssetByChainAndType(this.chain(), [_types._AssetType.NATIVE, _types._AssetType.LOCAL]);
     const swapAssetIdMap = Object.values(swapAssets).reduce((accumulator, asset) => {
       return {
         ...accumulator,
@@ -193,7 +232,7 @@ class HydradxHandler {
       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 substrateApi = this.chainService.getSubstrateApi(this.chain());
       const extrinsic = substrateApi.api.tx(txHex);
       const paymentInfo = await extrinsic.paymentInfo(request.address);
       const networkFee = {
@@ -225,6 +264,16 @@ class HydradxHandler {
             return new _SwapError.SwapError(_swap.SwapErrorType.NOT_ENOUGH_LIQUIDITY);
         }
       }
+
+      // const feeTokenOptions = this.chainService.getFeeTokensByChain(this.chain());
+      const feeTokenOptions = [fromChainNativeTokenSlug];
+
+      // if (request.feeToken && !feeTokenOptions.includes(request.feeToken)) {
+      //   return new SwapError(SwapErrorType.UNKNOWN);
+      // }
+
+      // const selectedFeeToken = request.feeToken || fromChainNativeTokenSlug;
+      const selectedFeeToken = fromChainNativeTokenSlug;
       return {
         pair: request.pair,
         fromAmount: request.fromAmount,
@@ -235,9 +284,10 @@ class HydradxHandler {
         feeInfo: {
           feeComponent: [networkFee, tradeFee],
           defaultFeeToken: fromChainNativeTokenSlug,
-          feeOptions: [fromChainNativeTokenSlug] // todo: parse fee options
+          feeOptions: feeTokenOptions,
+          // TODO: enable fee options
+          selectedFeeToken
         },
-
         isLowLiquidity: Math.abs(quoteResponse.priceImpactPct) >= HYDRADX_LOW_LIQUIDITY_THRESHOLD,
         route: swapRoute,
         metadata: txHex
@@ -289,10 +339,34 @@ class HydradxHandler {
       txData: xcmData
     };
   }
+  async handleSetFeeStep(params) {
+    var _swapFeeInfo$selected;
+    const substrateApi = this.chainService.getSubstrateApi(this.chain());
+    const chainApi = await substrateApi.isReady;
+    const swapStepIndex = params.process.steps.findIndex(step => step.type === _swap.SwapStepType.SWAP);
+    if (swapStepIndex <= -1) {
+      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+    }
+    const swapFeeInfo = params.process.totalFee[swapStepIndex];
+    const selectedFeeTokenSlug = (_swapFeeInfo$selected = swapFeeInfo.selectedFeeToken) !== null && _swapFeeInfo$selected !== void 0 ? _swapFeeInfo$selected : swapFeeInfo.defaultFeeToken;
+    const selectedFeeAsset = this.chainService.getAssetBySlug(selectedFeeTokenSlug);
+    const extrinsic = chainApi.api.tx.multiTransactionPayment.setCurrency((0, _utils._getTokenOnChainAssetId)(selectedFeeAsset));
+    const txData = {
+      selectedFeeToken: selectedFeeTokenSlug
+    };
+    return {
+      txChain: this.chain(),
+      extrinsic,
+      // extrinsicType: ExtrinsicType.SET_FEE_TOKEN,
+      extrinsicType: _KoniTypes.ExtrinsicType.SWAP,
+      chainType: _KoniTypes.ChainType.SUBSTRATE,
+      txData
+    };
+  }
   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 substrateApi = this.chainService.getSubstrateApi(this.chain());
     const chainApi = await substrateApi.isReady;
     const txData = {
       provider: this.providerInfo,
@@ -303,12 +377,25 @@ class HydradxHandler {
       process: params.process
     };
     let extrinsic;
+    const txList = [];
+    const swapTx = chainApi.api.tx(txHex);
     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)]);
+    const needSetReferral = !referral || referral === '';
+    const steps = params.process.steps.map(step => step.type);
+    const needSetFeeToken = steps.includes(_swap.SwapStepType.SET_FEE_TOKEN);
+    if (!needSetReferral && !needSetFeeToken) {
+      extrinsic = swapTx;
     } else {
-      extrinsic = chainApi.api.tx(txHex);
+      if (needSetReferral) {
+        txList.push(chainApi.api.tx.referrals.linkCode(this.referralCode));
+      }
+      if (needSetFeeToken) {
+        const nativeTokenInfo = this.chainService.getNativeTokenInfo(this.chain());
+        txList.push(chainApi.api.tx.multiTransactionPayment.setCurrency((0, _utils._getTokenOnChainAssetId)(nativeTokenInfo)));
+      }
+      txList.push(swapTx);
+      extrinsic = chainApi.api.tx.utility.batchAll(txList);
     }
     return {
       txChain: fromAsset.originChain,
@@ -332,7 +419,7 @@ class HydradxHandler {
       case _swap.SwapStepType.XCM:
         return this.handleXcmStep(params);
       case _swap.SwapStepType.SET_FEE_TOKEN:
-        return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.UNSUPPORTED));
+        return this.handleSetFeeStep(params);
       case _swap.SwapStepType.SWAP:
         return this.handleSubmitStep(params);
       default:
@@ -401,7 +488,7 @@ class HydradxHandler {
           error: _swap.SwapErrorType.ASSET_NOT_SUPPORTED
         };
       }
-      if (!(fromAsset.originChain === this.chain && toAsset.originChain === this.chain)) {
+      if (!(fromAsset.originChain === this.chain() && toAsset.originChain === this.chain())) {
         return {
           error: _swap.SwapErrorType.ASSET_NOT_SUPPORTED
         };
@@ -419,7 +506,7 @@ class HydradxHandler {
       }
       return {
         metadata: {
-          chain: this.chainService.getChainInfoByKey(this.chain)
+          chain: this.chainService.getChainInfoByKey(this.chain())
         }
       };
     } catch (e) {

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

@@ -90,6 +90,7 @@ class SwapService {
       request,
       selectedQuote: swapQuoteResponse.optimalQuote
     });
+    console.log('optimalProcess', optimalProcess);
     return {
       process: optimalProcess,
       quote: swapQuoteResponse

package/koni/background/handlers/Extension.d.ts

@@ -108,6 +108,7 @@ export default class KoniExtension {
     private derivationCreateV2;
     private jsonRestoreV2;
     private batchRestoreV2;
+    private batchExportV2;
     private getNftCollection;
     private subscribeNftCollection;
     private getNft;

package/koni/background/handlers/Extension.js

@@ -1393,6 +1393,26 @@ export default class KoniExtension {
       throw new Error(t('Wrong password'));
     }
   }
+  async batchExportV2({
+    addresses,
+    password
+  }) {
+    try {
+      if (addresses && !addresses.length) {
+        throw new Error(t('No accounts found to export'));
+      }
+      return {
+        exportedJson: await keyring.backupAccounts(password, addresses)
+      };
+    } catch (e) {
+      const error = e;
+      if (error.message === 'Invalid master password') {
+        throw new Error(t('Wrong password'));
+      } else {
+        throw error;
+      }
+    }
+  }
   getNftCollection() {
     return this.#koniState.getNftCollection();
   }
@@ -4000,6 +4020,9 @@ export default class KoniExtension {
       txChain,
       txData
     } = await this.#koniState.swapService.handleSwapProcess(inputData);
+    // const chosenFeeToken = process.steps.findIndex((step) => step.type === SwapStepType.SET_FEE_TOKEN) > -1;
+    // const allowSkipValidation = [ExtrinsicType.SET_FEE_TOKEN, ExtrinsicType.SWAP].includes(extrinsicType);
+
     return await this.#koniState.transactionService.handleTransaction({
       address,
       chain: txChain,
@@ -4011,6 +4034,7 @@ export default class KoniExtension {
       chainType,
       resolveOnDone: !isLastStep,
       transferNativeAmount
+      // skipFeeValidation: chosenFeeToken && allowSkipValidation
     });
   }
   /* Swap service */
@@ -4146,6 +4170,8 @@ export default class KoniExtension {
         return this.subscribeCrowdloan(id, port);
       case 'pri(derivation.createV2)':
         return this.derivationCreateV2(request);
+      case 'pri(accounts.batchExportV2)':
+        return this.batchExportV2(request);
       case 'pri(json.restoreV2)':
         return this.jsonRestoreV2(request);
       case 'pri(json.batchRestoreV2)':

package/koni/background/handlers/State.js

@@ -32,7 +32,7 @@ import { SwapService } from '@subwallet/extension-base/services/swap-service';
 import TransactionService from '@subwallet/extension-base/services/transaction-service';
 import WalletConnectService from '@subwallet/extension-base/services/wallet-connect-service';
 import AccountRefStore from '@subwallet/extension-base/stores/AccountRef';
-import { isAccountAll, stripUrl, TARGET_ENV, wait } from '@subwallet/extension-base/utils';
+import { isAccountAll, stripUrl, TARGET_ENV } from '@subwallet/extension-base/utils';
 import { isContractAddress, parseContractInput } from '@subwallet/extension-base/utils/eth/parseTransaction';
 import { createPromiseHandler } from '@subwallet/extension-base/utils/promise';
 import { decodePair } from '@subwallet/keyring/pair/decode';
@@ -1204,34 +1204,17 @@ export default class KoniState {
       maxFeePerGas: autoFormatNumber(transactionParams.maxFeePerGas),
       data: transactionParams.data
     };
-    const getTransactionGas = async () => {
-      try {
-        transaction.gas = await web3.eth.estimateGas({
-          ...transaction
-        });
-      } catch (e) {
-        // @ts-ignore
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-        throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, e === null || e === void 0 ? void 0 : e.message);
-      }
-    };
 
     // Calculate transaction data
     try {
-      await Promise.race([getTransactionGas(), wait(3000).then(async () => {
-        if (!transaction.gas) {
-          await this.chainService.initSingleApi(networkKey);
-          await getTransactionGas();
-        }
-      })]);
+      transaction.gas = await web3.eth.estimateGas({
+        ...transaction
+      });
     } catch (e) {
       // @ts-ignore
       // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
       throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, e === null || e === void 0 ? void 0 : e.message);
     }
-    if (!transaction.gas) {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS);
-    }
     let estimateGas;
 
     // TODO: Review, If not override, transaction maybe fail because fee too low

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.1.53-beta.0",
+  "version": "1.1.55-0",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -1851,7 +1851,7 @@
     "@ethereumjs/common": "^4.1.0",
     "@ethereumjs/tx": "^5.1.0",
     "@ethersproject/abi": "^5.7.0",
-    "@galacticcouncil/sdk": "^1.2.1",
+    "@galacticcouncil/sdk": "^2.1.0",
     "@json-rpc-tools/utils": "^1.7.6",
     "@metamask/safe-event-emitter": "^2.0.0",
     "@metaverse-network-sdk/type-definitions": "^0.0.1-13",
@@ -1873,13 +1873,13 @@
     "@reduxjs/toolkit": "^1.9.1",
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.7.26",
-    "@subwallet/chain-list": "0.2.55-beta.3",
-    "@subwallet/extension-base": "^1.1.53-0",
-    "@subwallet/extension-chains": "^1.1.53-0",
-    "@subwallet/extension-dapp": "^1.1.53-0",
-    "@subwallet/extension-inject": "^1.1.53-0",
-    "@subwallet/keyring": "^0.1.3",
-    "@subwallet/ui-keyring": "^0.1.3",
+    "@subwallet/chain-list": "0.2.55",
+    "@subwallet/extension-base": "^1.1.55-0",
+    "@subwallet/extension-chains": "^1.1.55-0",
+    "@subwallet/extension-dapp": "^1.1.55-0",
+    "@subwallet/extension-inject": "^1.1.55-0",
+    "@subwallet/keyring": "^0.1.5",
+    "@subwallet/ui-keyring": "^0.1.5",
     "@walletconnect/sign-client": "^2.8.4",
     "@walletconnect/types": "^2.8.4",
     "@walletconnect/utils": "^2.8.4",
@@ -1914,4 +1914,4 @@
     "web3-eth-contract": "^1.10.0",
     "web3-utils": "^1.10.0"
   }
-}
+}

package/packageInfo.js

@@ -7,5 +7,5 @@ export const packageInfo = {
   name: '@subwallet/extension-base',
   path: (import.meta && import.meta.url) ? new URL(import.meta.url).pathname.substring(0, new URL(import.meta.url).pathname.lastIndexOf('/') + 1) : 'auto',
   type: 'esm',
-  version: '1.1.53-0'
+  version: '1.1.55-0'
 };

package/services/chain-service/index.d.ts

@@ -93,7 +93,6 @@ export declare class ChainService {
     autoEnableTokens(): Promise<void>;
     handleLatestData(): void;
     private initApis;
-    initSingleApi(slug: string): Promise<boolean>;
     private initApiForChain;
     private destroyApiForChain;
     enableChain(chainSlug: string): Promise<boolean>;
@@ -143,4 +142,5 @@ export declare class ChainService {
     getMetadataByHash(hash: string): import("dexie").PromiseExtended<IMetadataItem | undefined>;
     getSubscanChainMap(reverse?: boolean): Record<string, string>;
     get detectBalanceChainSlugMap(): Record<string, string>;
+    getFeeTokensByChain(chainSlug: string): string[];
 }