@subwallet/extension-base 1.3.63-0 → 1.3.65-0

package/cjs/koni/api/staking/bonding/utils.js

@@ -11,6 +11,7 @@ exports.calculateAlephZeroValidatorReturn = calculateAlephZeroValidatorReturn;
 exports.calculateAnalogChainStakedReturn = calculateAnalogChainStakedReturn;
 exports.calculateChainStakedReturn = calculateChainStakedReturn;
 exports.calculateChainStakedReturnV2 = calculateChainStakedReturnV2;
+exports.calculateEnergyWebCollatorReturn = calculateEnergyWebCollatorReturn;
 exports.calculateInflation = calculateInflation;
 exports.calculateTernoaValidatorReturn = calculateTernoaValidatorReturn;
 exports.calculateValidatorStakedReturn = calculateValidatorStakedReturn;
@@ -139,6 +140,11 @@ async function calculateChainStakedReturnV2(chainInfo, totalIssuance, erasPerDay
 function calculateAlephZeroValidatorReturn(chainStakedReturn, commission) {
   return chainStakedReturn * (100 - commission) / 100;
 }
+function calculateEnergyWebCollatorReturn(annualReward, collatorCommission, numberCollators, totalStake) {
+  const rewardForNominators = new _bignumber.default(annualReward).multipliedBy(1 - collatorCommission);
+  const rewardPerNominator = rewardForNominators.div(numberCollators);
+  return rewardPerNominator.div(totalStake).shiftedBy(2).toNumber();
+}
 function calculateTernoaValidatorReturn(rewardPerValidator, validatorStake, commission) {
   const percentRewardForNominators = (100 - commission) / 100;
   const rewardForNominators = rewardPerValidator * percentRewardForNominators;

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

@@ -1837,6 +1837,7 @@ class KoniState {
       await this.priceService.setPriceCurrency(DEFAULT_CURRENCY);
       this.settingService.resetWallet();
       await this.priceService.setPriceCurrency(DEFAULT_CURRENCY);
+      this.chainService.resetPopularTokenList();
     }
     this.chainService.resetWallet(resetAll);
     await this.walletConnectService.resetWallet(resetAll);

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.63-0'
+  version: '1.3.65-0'
 };
 exports.packageInfo = packageInfo;

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

@@ -38,13 +38,14 @@ class BalanceService {
   stopPromiseHandler = (0, _utils2.createPromiseHandler)();
   status = _types.ServiceStatus.NOT_INITIALIZED;
   isReload = false;
+  requireOptimizeTokenList = false;
   get isStarted() {
     return this.status === _types.ServiceStatus.STARTED;
   }
   detectAccountBalanceStore = new _DetectAccountBalance.default();
   balanceDetectSubject = new _rxjs.BehaviorSubject({});
-  intervalTime = 3 * 60 * 1000;
-  cacheTime = 15 * 60 * 1000;
+  intervalTime = 3 * 60 * 1000; // scan balance every 3 mins
+  cacheTime = 15 * 60 * 1000; // cache time 15 mins to run again
 
   /**
    * @constructor
@@ -96,6 +97,10 @@ class BalanceService {
     this.stopPromiseHandler = (0, _utils2.createPromiseHandler)();
     this.status = _types.ServiceStatus.STARTED;
     this.startPromiseHandler.resolve();
+    if (this.requireOptimizeTokenList) {
+      await this.optimizeEnableTokens();
+      this.requireOptimizeTokenList = false;
+    }
   }
 
   /** Stop service */
@@ -456,18 +461,12 @@ class BalanceService {
       const type = (0, _keyring.getKeypairTypeByAddress)(address);
       const typeValid = [..._types2.EthereumKeypairTypes].includes(type);
       if (typeValid) {
-        return new Promise(resolve => {
-          const timeOutPromise = new Promise(_resolve => {
-            setTimeout(() => _resolve([]), 30000);
-          });
-          const balanceDetectionApi = _subwalletServicesSdk.default.balanceDetectionApi || Promise.resolve([]);
-          Promise.race([timeOutPromise, balanceDetectionApi.getEvmTokenBalanceSlug(address)]).then(result => resolve(result)).catch(error => {
-            console.error(error);
-            resolve(null);
-          });
+        return _subwalletServicesSdk.default.balanceDetectionApi.getSubWalletTokenBalance(address).catch(e => {
+          console.error(e);
+          return null;
         });
       } else {
-        return Promise.resolve(null);
+        return null;
       }
     });
     const needEnableChains = [];
@@ -525,13 +524,13 @@ class BalanceService {
     }
     for (const balanceData of evmBalanceDataList) {
       if (balanceData) {
-        for (const slug of balanceData) {
+        for (const tokenSlug of balanceData) {
           var _currentAssetSettings2;
-          const chainSlug = slug.split('-')[0];
+          const chainSlug = tokenSlug.split('-')[0];
           const chainState = this.state.chainService.getChainStateByKey(chainSlug);
-          const existedKey = Object.keys(assetMap).find(v => v.toLowerCase() === slug.toLowerCase());
+          const existedKey = Object.keys(assetMap).find(v => v.toLowerCase() === tokenSlug.toLowerCase());
 
-          // Cancel is chain is turned off by user
+          // Cancel if chain is turned off by user
           if (chainState && chainState.manualTurnOff) {
             continue;
           }
@@ -637,5 +636,148 @@ class BalanceService {
     }
     return (0, _process.getDefaultTransferProcess)();
   }
+
+  // only evm addresses
+  async evmDetectBalanceToken(addresses) {
+    const assetMap = this.state.chainService.getAssetRegistry();
+    const evmPromiseList = addresses.map(address => {
+      return _subwalletServicesSdk.default.balanceDetectionApi.getSubWalletTokenBalance(address).catch(e => {
+        console.error(e);
+        return null;
+      });
+    });
+    const needActiveTokens = [];
+    const evmBalanceDataList = await Promise.all(evmPromiseList);
+    for (const balanceData of evmBalanceDataList) {
+      if (balanceData) {
+        for (const tokenSlug of balanceData) {
+          const chainSlug = tokenSlug.split('-')[0];
+          const chainState = this.state.chainService.getChainStateByKey(chainSlug);
+          const existedKey = Object.keys(assetMap).find(v => v.toLowerCase() === tokenSlug.toLowerCase());
+
+          // Cancel is chain is turned off by user
+          if (chainState && chainState.manualTurnOff) {
+            continue;
+          }
+          if (existedKey) {
+            needActiveTokens.push(existedKey);
+          }
+        }
+      }
+    }
+    return needActiveTokens;
+  }
+
+  // only for substrate addresses
+  async substrateDetectBalanceToken(addresses) {
+    const assetMap = this.state.chainService.getAssetRegistry();
+    const promiseList = addresses.map(address => {
+      return this.state.subscanService.getMultiChainBalance(address).catch(e => {
+        console.error(e);
+        return null;
+      });
+    });
+    const needActiveTokens = [];
+    const balanceDataList = await Promise.all(promiseList);
+    const chainInfoMap = this.state.chainService.getChainInfoMap();
+    const detectBalanceChainSlugMap = this.state.chainService.detectBalanceChainSlugMap;
+    for (const balanceData of balanceDataList) {
+      if (balanceData) {
+        for (const balanceDatum of balanceData) {
+          const {
+            balance,
+            bonded,
+            category,
+            locked,
+            network,
+            symbol
+          } = balanceDatum;
+          const chain = detectBalanceChainSlugMap[network];
+          const chainState = this.state.chainService.getChainStateByKey(chain);
+          const chainInfo = chain ? chainInfoMap[chain] : null;
+          const balanceIsEmpty = (!balance || balance === '0') && (!locked || locked === '0') && (!bonded || bonded === '0');
+          const tokenKey = `${chain}-${category === 'native' ? 'NATIVE' : 'LOCAL'}-${symbol.toUpperCase()}`;
+          const existedKey = Object.keys(assetMap).find(v => v.toLowerCase() === tokenKey.toLowerCase());
+
+          // Cancel if chain is not supported or is testnet
+          if (!chainInfo || chainInfo.isTestnet) {
+            continue;
+          }
+
+          // Cancel is balance is 0
+          if (balanceIsEmpty) {
+            continue;
+          }
+
+          // Cancel is chain is turned off by user
+          if (chainState && chainState.manualTurnOff) {
+            continue;
+          }
+          if (existedKey) {
+            needActiveTokens.push(existedKey);
+          }
+        }
+      }
+    }
+    return needActiveTokens;
+  }
+  async evmDetectBalanceChain() {
+    const blockscoutChain = await _subwalletServicesSdk.default.balanceDetectionApi.getBlockscoutChainData();
+    const blockscoutChainId = Object.keys(blockscoutChain);
+    const evmDetectChain = Object.values(this.state.chainService.getChainInfoMap()).filter(info => {
+      var _info$evmInfo, _info$evmInfo2;
+      return !!((_info$evmInfo = info.evmInfo) !== null && _info$evmInfo !== void 0 && _info$evmInfo.evmChainId) && blockscoutChainId.includes((_info$evmInfo2 = info.evmInfo) === null || _info$evmInfo2 === void 0 ? void 0 : _info$evmInfo2.evmChainId.toString());
+    }).map(chainInfo => chainInfo.slug);
+    return evmDetectChain;
+  }
+  substrateDetectBalanceChain() {
+    const substrateDetectChain = Object.values(this.state.chainService.getChainInfoMap()).filter(info => {
+      var _info$extraInfo;
+      return !!info.substrateInfo && !!((_info$extraInfo = info.extraInfo) !== null && _info$extraInfo !== void 0 && _info$extraInfo.chainBalanceSlug);
+    }).map(chainInfo => chainInfo.slug);
+    return substrateDetectChain;
+  }
+
+  /** optimize token area **/
+
+  enableOptimizeTokenPromise() {
+    this.requireOptimizeTokenList = true;
+  }
+  async optimizeEnableTokens() {
+    try {
+      const assetSettings = await this.state.chainService.getAssetSettings();
+      const assetMap = this.state.chainService.getAssetRegistry();
+      const addresses = _uiKeyring.default.getPairs().map(account => account.address);
+      const evmAddresses = addresses.filter(address => [..._types2.EthereumKeypairTypes].includes((0, _keyring.getKeypairTypeByAddress)(address)));
+      const substrateAddresses = addresses.filter(address => [..._types2.SubstrateKeypairTypes].includes((0, _keyring.getKeypairTypeByAddress)(address)));
+      const [nonZeroBalanceEvmToken, nonZeroBalanceSubstrateToken] = await Promise.all([this.evmDetectBalanceToken(evmAddresses), this.substrateDetectBalanceToken(substrateAddresses)]);
+      const substrateDetectChain = this.substrateDetectBalanceChain();
+      const evmDetectChain = await this.evmDetectBalanceChain();
+      const updatedSettings = structuredClone(assetSettings);
+      Object.entries(assetSettings).forEach(_ref => {
+        let [tokenSlug, setting] = _ref;
+        const isNonZeroBalanceToken = nonZeroBalanceEvmToken.includes(tokenSlug) || nonZeroBalanceSubstrateToken.includes(tokenSlug);
+        const assetInfo = assetMap[tokenSlug];
+        const isEvmDetectChain = evmDetectChain.includes(assetInfo.originChain);
+        const isSubstrateDetectChain = substrateDetectChain.includes(assetInfo.originChain);
+        if (isNonZeroBalanceToken && !setting.visible) {
+          // enable non-zero balance tokens
+          updatedSettings[tokenSlug] = {
+            visible: true
+          };
+        } else if (!isNonZeroBalanceToken && setting.visible && !(0, _utils._isNativeToken)(assetInfo) && !(0, _utils._isCustomAsset)(tokenSlug) && (isEvmDetectChain || isSubstrateDetectChain)) {
+          // hide tokens with zero balance that aren't native or custom
+          updatedSettings[tokenSlug] = {
+            visible: false
+          };
+        }
+      });
+      this.state.chainService.setAssetSettings(updatedSettings);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+
+  /** optimize token area **/
 }
 exports.BalanceService = BalanceService;

package/cjs/services/balance-service/transfer/xcm/acrossBridge/index.js

@@ -6,17 +6,21 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports._isAcrossChainBridge = _isAcrossChainBridge;
 exports._isAcrossTestnetBridge = _isAcrossTestnetBridge;
-exports.getAcrossQuote = void 0;
+exports.getAcrossSendingValue = exports.getAcrossQuote = void 0;
 var _chainList = require("@subwallet/chain-list");
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _xcmParser = require("@subwallet/extension-base/core/substrate/xcm-parser");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _types = require("@subwallet/extension-base/types");
 var _subwalletServicesSdk = _interopRequireDefault(require("@subwallet-monorepos/subwallet-services-sdk"));
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
 // Across Bridge
 const acrossPairsMap = new Map([[_chainList.COMMON_CHAIN_SLUGS.ETHEREUM, new Set(['optimism', 'base_mainnet', 'arbitrum_one'])], ['optimism', new Set([_chainList.COMMON_CHAIN_SLUGS.ETHEREUM, 'base_mainnet', 'arbitrum_one'])], ['base_mainnet', new Set([_chainList.COMMON_CHAIN_SLUGS.ETHEREUM, 'optimism', 'arbitrum_one'])], ['arbitrum_one', new Set([_chainList.COMMON_CHAIN_SLUGS.ETHEREUM, 'optimism', 'base_mainnet'])], [_chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA, new Set(['base_sepolia', 'arbitrum_sepolia'])],
 // TESTNET START HERE
-['base_sepolia', new Set([_chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA])], ['arbitrum_sepolia', new Set([_chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA])]]);
+['base_sepolia', new Set([_chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA, 'arbitrum_sepolia'])], ['arbitrum_sepolia', new Set([_chainList.COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA, 'base_sepolia'])]]);
 function _isAcrossChainBridge(srcChain, destChain) {
   var _acrossPairsMap$get$h, _acrossPairsMap$get;
   return (_acrossPairsMap$get$h = (_acrossPairsMap$get = acrossPairsMap.get(srcChain)) === null || _acrossPairsMap$get === void 0 ? void 0 : _acrossPairsMap$get.has(destChain)) !== null && _acrossPairsMap$get$h !== void 0 ? _acrossPairsMap$get$h : false;
@@ -43,7 +47,7 @@ const getAcrossQuote = async _ref => {
     throw new Error('Sender is required');
   }
   try {
-    const data = await _subwalletServicesSdk.default.xcmApi.fetchXcmData({
+    const data = await _subwalletServicesSdk.default.bridgeApi.fetchBridgeData({
       address: sender,
       from: originTokenInfo.slug,
       to: destinationTokenInfo.slug,
@@ -61,4 +65,46 @@ const getAcrossQuote = async _ref => {
     return Promise.reject(new Error((error === null || error === void 0 ? void 0 : error.message) || 'Unable to perform this transaction at the moment. Try again later'));
   }
 };
-exports.getAcrossQuote = getAcrossQuote;
+
+// TODO: update logic after add across metadata for chainlist
+exports.getAcrossQuote = getAcrossQuote;
+const acrossNativeTokenAddresses = {
+  mainnet: {
+    arbitrum_one: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
+    base_mainnet: '0x4200000000000000000000000000000000000006',
+    ethereum: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+    optimism: '0x4200000000000000000000000000000000000006'
+  },
+  testnet: {
+    arbitrum_sepolia: '0x980B62Da83eFf3D4576C647993b0c1D7faf17c73',
+    base_sepolia: '0x4200000000000000000000000000000000000006',
+    sepolia_ethereum: '0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14'
+  }
+};
+const getAcrossSendingValue = async (originChain, originTokenInfo, destinationChain, isTestnet) => {
+  try {
+    const originChainId = (0, _utils._getEvmChainId)(originChain);
+    const destinationChainId = (0, _utils._getEvmChainId)(destinationChain);
+    if (!originChainId || !destinationChainId) {
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS));
+    }
+    const contracts = isTestnet ? acrossNativeTokenAddresses.testnet : acrossNativeTokenAddresses.mainnet;
+    const fromContract = (0, _utils._getContractAddressOfToken)(originTokenInfo) || contracts[originTokenInfo.originChain];
+    const acrossBridgeLimit = await _subwalletServicesSdk.default.bridgeApi.getAcrossBridgeLimit(originChainId, destinationChainId, fromContract, isTestnet);
+    if (!acrossBridgeLimit.minDeposit || !acrossBridgeLimit.maxDeposit) {
+      throw new Error('Invalid Across Bridge response');
+    }
+    const min = new _bignumber.default(acrossBridgeLimit.minDeposit);
+    const max = new _bignumber.default(acrossBridgeLimit.maxDeposit);
+    // Use the midpoint between minDeposit and maxDeposit as a balanced value used for estimating gas fee more accurately
+    const sendingValue = min.plus(max).div(2).toFixed(0);
+    return sendingValue;
+  } catch (error) {
+    console.error('Across Bridge error:', error);
+
+    // fallback in case fetch API fail
+    const defaultSendingAmount = isTestnet ? 0.0037 : 1;
+    return new _bignumber.default(defaultSendingAmount).shiftedBy((0, _utils._getAssetDecimals)(originTokenInfo)).toFixed(0, _bignumber.default.ROUND_FLOOR);
+  }
+};
+exports.getAcrossSendingValue = getAcrossSendingValue;

package/cjs/services/balance-service/transfer/xcm/index.js

@@ -201,7 +201,7 @@ const createAcrossBridgeExtrinsic = async _ref6 => {
     throw new Error('Sender is required');
   }
   try {
-    const data = await _subwalletServicesSdk.default.xcmApi.fetchXcmData({
+    const data = await _subwalletServicesSdk.default.bridgeApi.fetchBridgeData({
       address: sender,
       from: originTokenInfo.slug,
       to: destinationTokenInfo.slug,
@@ -224,10 +224,15 @@ const createAcrossBridgeExtrinsic = async _ref6 => {
     transactionConfig.gas = gasLimit.toString();
     return transactionConfig;
   } catch (error) {
+    var _message, _message$toLowerCase;
     if (error instanceof SyntaxError) {
       return Promise.reject(new Error('Unable to perform this transaction at the moment. Try again later'));
     }
-    return Promise.reject(new Error((error === null || error === void 0 ? void 0 : error.message) || 'Unable to perform this transaction at the moment. Try again later'));
+    const message = (error === null || error === void 0 ? void 0 : (_message = error.message) === null || _message === void 0 ? void 0 : (_message$toLowerCase = _message.toLowerCase) === null || _message$toLowerCase === void 0 ? void 0 : _message$toLowerCase.call(_message)) || '';
+    if (!message.includes('amount')) {
+      return Promise.reject(new Error('Unable to perform this transaction at the moment. Try again later'));
+    }
+    return Promise.reject(new Error(error === null || error === void 0 ? void 0 : error.message));
   }
 };
 exports.createAcrossBridgeExtrinsic = createAcrossBridgeExtrinsic;

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

@@ -274,9 +274,6 @@ class ChainOnlineService {
           this.chainService.subscribeChainInfoMap().next(chainInfoMap);
           this.chainService.setAssetRegistry(assetRegistry);
           this.chainService.subscribeAssetRegistry().next(assetRegistry);
-          this.chainService.autoEnableTokens().then(() => {
-            this.eventService.emit('asset.updateState', '');
-          }).catch(console.error);
           this.chainService.setChainStateMap(currentChainStateMap);
           this.chainService.subscribeChainStateMap().next(currentChainStateMap);
           this.chainService.subscribeChainStatusMap().next(currentChainStatusMap);

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

@@ -605,7 +605,6 @@ class ChainService {
     this.xcmRefMapSubject.next(this.xcmRefMap);
     await this.initApis();
     this.initAssetSettings();
-    await this.autoEnableTokens();
   }
   initAssetRefMap() {
     this.dataMap.assetRefMap = _chainList.AssetRefMap;
@@ -683,6 +682,12 @@ class ChainService {
       }
     }
   }
+  resetPopularTokenList() {
+    this.priorityTokensSubject.next({
+      token: {},
+      tokenGroup: {}
+    });
+  }
   async enablePopularTokens() {
     const assetSettings = this.assetSettingSubject.value;
     const chainStateMap = this.getChainStateMap();

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

@@ -12,7 +12,7 @@ const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
 const fetchDomain = process.env.PATCH_CHAIN_LIST_URL || (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.119'; // update this when build chain-list
+const ChainListVersion = '0.2.120'; // update this when build chain-list
 
 // todo: move this interface to chainlist
 exports.ChainListVersion = ChainListVersion;

package/cjs/services/earning-service/constants/chains.js

@@ -46,8 +46,6 @@ exports.MANTA_MIN_DELEGATION = MANTA_MIN_DELEGATION;
 const CHANNEL_ID = 7;
 exports.CHANNEL_ID = CHANNEL_ID;
 const STAKING_IDENTITY_API_SLUG = {
-  // @TODO: Remove polkadot then migrate
-  polkadot: 'polkadot_people',
   statemine: 'peopleKusama',
   statemint: 'polkadot_people'
 };

package/cjs/services/earning-service/handlers/lending/interlay.js

@@ -15,6 +15,7 @@ var _base = _interopRequireDefault(require("./base"));
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+// TODO: disable earning and stake actions but keep showing existing earning positions (currently handle on UI)
 class InterlayLendingPoolHandler extends _base.default {
   altInputAsset = 'polkadot-NATIVE-DOT';
   derivativeAssets = ['interlay-LOCAL-qDOT'];

package/cjs/services/earning-service/handlers/liquid-staking/acala.js

@@ -21,7 +21,7 @@ function convertDerivativeToken(amount, exchangeRate, decimals) {
   return amount.mul(new _util.BN(exchangeRate)).div(_util.BN_TEN.pow(new _util.BN(decimals)));
 }
 class AcalaLiquidStakingPoolHandler extends _base.default {
-  altInputAsset = 'polkadot-NATIVE-DOT';
+  altInputAsset = 'statemint-NATIVE-DOT';
   derivativeAssets = ['acala-LOCAL-LDOT'];
   inputAsset = 'acala-LOCAL-DOT';
   rewardAssets = ['acala-LOCAL-DOT'];

package/cjs/services/earning-service/handlers/liquid-staking/bifrost.js

@@ -21,7 +21,7 @@ const STATS_URL = 'https://dapi.bifrost.io/api/site';
 const BIFROST_GRAPHQL_ENDPOINT = 'https://bifrost-subsql.liebi.com/v1/graphql';
 const BIFROST_EXCHANGE_RATE_REQUEST = 'query MyQuery{slp_polkadot_ratio(limit:1 where:{key:{_eq:"0"}} order_by:{timestamp:desc_nulls_first}){ratio key timestamp total_issuance token_pool}}';
 class BifrostLiquidStakingPoolHandler extends _base.default {
-  altInputAsset = 'polkadot-NATIVE-DOT';
+  altInputAsset = 'statemint-NATIVE-DOT';
   derivativeAssets = ['bifrost_dot-LOCAL-vDOT'];
   inputAsset = 'bifrost_dot-LOCAL-DOT';
   rewardAssets = ['bifrost_dot-LOCAL-DOT'];

package/cjs/services/earning-service/handlers/liquid-staking/parallel.js

@@ -15,6 +15,7 @@ var _base = _interopRequireDefault(require("./base"));
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+// TODO: disable earning and stake actions but keep showing existing earning positions (currently handle on UI)
 class ParallelLiquidStakingPoolHandler extends _base.default {
   altInputAsset = 'polkadot-NATIVE-DOT';
   derivativeAssets = ['parallel-LOCAL-sDOT'];

package/cjs/services/earning-service/handlers/native-staking/energy.js

@@ -17,6 +17,9 @@ var _basePara = _interopRequireDefault(require("./base-para"));
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+const DEFAULT_ANNUAL_REWARD = {
+  energy_web_x: 2000000
+};
 class EnergyNativeStakingPoolHandler extends _basePara.default {
   /* Subscribe pool info */
 
@@ -60,6 +63,13 @@ class EnergyNativeStakingPoolHandler extends _basePara.default {
       const unstakingPeriod = parseInt(unstakingDelay.toString()) * eraTime;
       const minStake = '0';
       const minToHuman = (0, _utils3.formatNumber)(minStake.toString(), nativeToken.decimals || 0, _utils3.balanceFormatter);
+      const collators = await this.getPoolTargets();
+      let maxApy = 0;
+      for (const collator of collators) {
+        if (collator.expectedReturn && collator.expectedReturn > maxApy) {
+          maxApy = collator.expectedReturn;
+        }
+      }
       const data = {
         ...this.baseInfo,
         type: this.type,
@@ -83,8 +93,7 @@ class EnergyNativeStakingPoolHandler extends _basePara.default {
           // TODO recheck
           era,
           eraTime,
-          totalApy: undefined,
-          // not have
+          totalApy: maxApy,
           tvl: totalStake.toString(),
           unstakingPeriod: unstakingPeriod
         },
@@ -257,12 +266,21 @@ class EnergyNativeStakingPoolHandler extends _basePara.default {
     const apiProps = await this.substrateApi.isReady;
     const substrateIdentityApi = this.substrateIdentityApi;
     const allCollators = [];
-    const [_allCollators, _selectedCandidates] = await Promise.all([apiProps.api.query.parachainStaking.candidateInfo.entries(),
-    // use it when energy support collatorCommission
-    // apiProps.api.query.parachainStaking.collatorCommission(),
-    apiProps.api.query.parachainStaking.selectedCandidates()]);
+    const [_allCollators, _selectedCandidates, _eraInfo, unstakingDelay] = await Promise.all([apiProps.api.query.parachainStaking.candidateInfo.entries(), apiProps.api.query.parachainStaking.selectedCandidates(), apiProps.api.query.parachainStaking.era(), apiProps.api.query.parachainStaking.delay()]);
+    const delay = parseInt(unstakingDelay.toString()); // in era unit
+    const roundInfo = _eraInfo.toPrimitive();
+    const currentRound = roundInfo.current;
+    let defaultCommission = 0;
+    if (apiProps.api.query.parachainStaking.defaultCollatorCommission) {
+      const _defaultCommission = await apiProps.api.query.parachainStaking.defaultCollatorCommission();
+      const {
+        current
+      } = _defaultCommission.toPrimitive();
+      defaultCommission = current / 1000000000;
+    }
     const maxNominationPerCollator = apiProps.api.consts.parachainStaking.maxTopNominationsPerCandidate.toString();
     const selectedCollators = _selectedCandidates.toPrimitive();
+    const selectedCollatorsCount = selectedCollators.length;
     for (const collator of _allCollators) {
       const _collatorAddress = collator[0].toHuman();
       const collatorAddress = _collatorAddress[0];
@@ -289,6 +307,41 @@ class EnergyNativeStakingPoolHandler extends _basePara.default {
         });
       }
     }
+    const annualReward = DEFAULT_ANNUAL_REWARD[this.chain] ? new _util.BN(DEFAULT_ANNUAL_REWARD[this.chain]).mul(_util.BN_TEN.pow(new _util.BN(this.nativeToken.decimals || 18))) : _util.BN_ZERO;
+
+    // calculate expected return
+    await Promise.all(allCollators.map(async collator => {
+      if (!selectedCollators.includes(collator.address) || annualReward.lte(_util.BN_ZERO)) {
+        return;
+      }
+      const [_topNominations, _nominationScheduledRequests] = await Promise.all([apiProps.api.query.parachainStaking.topNominations(collator.address), apiProps.api.query.parachainStaking.nominationScheduledRequests(collator.address)]);
+      const nominationScheduledRequests = _nominationScheduledRequests.toPrimitive();
+      const topNominations = _topNominations.toPrimitive();
+      const topNominationsRecord = topNominations.nominations.reduce((record, _ref) => {
+        let {
+          amount,
+          owner
+        } = _ref;
+        record[owner] = amount || '0';
+        return record;
+      }, {});
+      let bnTotalActiveStake = new _util.BN(collator.totalStake);
+      if (nominationScheduledRequests !== null && nominationScheduledRequests !== void 0 && nominationScheduledRequests.length) {
+        const bnTotalInactiveStake = nominationScheduledRequests.reduce((partialSum, _ref2) => {
+          let {
+            action,
+            nominator,
+            whenExecutable
+          } = _ref2;
+          if (whenExecutable + delay - parseInt(currentRound) < 0 && action) {
+            return partialSum.add(new _util.BN(topNominationsRecord[nominator] || Object.values(action)[0] || _util.BN_ZERO));
+          }
+          return partialSum;
+        }, _util.BN_ZERO);
+        bnTotalActiveStake = bnTotalActiveStake.sub(bnTotalInactiveStake);
+      }
+      collator.expectedReturn = (0, _utils.calculateEnergyWebCollatorReturn)(annualReward.toString(), defaultCommission, selectedCollatorsCount, bnTotalActiveStake.toString());
+    }));
     const extraInfoMap = {};
     await Promise.all(allCollators.map(async collator => {
       const [_info, [identity, isReasonable]] = await Promise.all([apiProps.api.query.parachainStaking.candidateInfo(collator.address), (0, _utils2.parseIdentity)(substrateIdentityApi, collator.address)]);
@@ -304,6 +357,7 @@ class EnergyNativeStakingPoolHandler extends _basePara.default {
       validator.blocked = !extraInfoMap[validator.address].active;
       validator.identity = extraInfoMap[validator.address].identity;
       validator.isVerified = extraInfoMap[validator.address].isVerified;
+      validator.commission = defaultCommission * 100;
     }
     return allCollators;
   }

package/cjs/services/earning-service/handlers/native-staking/relay-chain.js

@@ -67,10 +67,7 @@ class RelayNativeStakingPoolHandler extends _base.default {
       }
       const unlimitedNominatorRewarded = substrateApi.api.consts.staking.maxExposurePageSize !== undefined;
       const maxNominatorRewarded = (_substrateApi$api$con = substrateApi.api.consts.staking.maxNominatorRewardedPerValidator) === null || _substrateApi$api$con === void 0 ? void 0 : _substrateApi$api$con.toString();
-
-      // hotfix for kusama asset hub migration
-      const kahMaxNominations = '24';
-      const maxNominations = chainInfo.slug === 'statemine' ? kahMaxNominations : await (0, _utils.getRelayMaxNominations)(substrateApi, this.chain);
+      const maxNominations = await (0, _utils.getRelayMaxNominations)(substrateApi, this.chain);
       const currentEra = _currentEra.toString();
       const maxUnlockingChunks = substrateApi.api.consts.staking.maxUnlockingChunks.toString();
       const unlockingEras = substrateApi.api.consts.staking.bondingDuration.toString();