@subwallet/extension-base 1.3.64-0 → 1.3.66-0

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.64-0'
+  version: '1.3.66-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.120'; // update this when build chain-list
+const ChainListVersion = '0.2.121'; // 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/tanssi.js

@@ -7,13 +7,36 @@ Object.defineProperty(exports, "__esModule", {
 exports.default = void 0;
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+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 = _interopRequireDefault(require("bignumber.js"));
-var _utils = require("../../utils");
+var _utils3 = require("../../utils");
 var _basePara = _interopRequireDefault(require("./base-para"));
 // Copyright 2019-2022 @subwallet/extension-base
 // SPDX-License-Identifier: Apache-2.0
 
+// Constants
+const sequencersPerAppchain = new _bignumber.default(5);
+const rewardsForStakers = new _bignumber.default(0.8);
+const blocksPerYear = new _bignumber.default(5256000); // 6 seconds block time hence 365 * 24 * 60 * 60 / 6 (5.256.000) blocks per year
+
+function calculateCollatorApy(rewardsPerBlock, totalStake, nativeTokenDecimals) {
+  const rewardsPerChainPerYear = new _bignumber.default(rewardsPerBlock).times(blocksPerYear);
+  const rewardsPerSequencerPerYear = rewardsPerChainPerYear.div(sequencersPerAppchain);
+  const rewardsForStakersPerSequencerPerYear = rewardsPerSequencerPerYear.times(rewardsForStakers);
+  const formattedTotalStake = (0, _utils2.formatNumber)(totalStake.toString(), nativeTokenDecimals);
+  if (formattedTotalStake === '0') {
+    return new _bignumber.default(0);
+  }
+  return rewardsForStakersPerSequencerPerYear.times(100).div(formattedTotalStake);
+}
+async function getActiveCollators(api) {
+  const collatorAssignment = await api.query.tanssiCollatorAssignment.collatorContainerChain();
+  const activeCollatorContainerChain = collatorAssignment.toPrimitive();
+  const activeCollators = Object.values(activeCollatorContainerChain.containerChains || {}).flat().map(c => c.toString());
+  return activeCollators;
+}
 function perbillToPercentBn(perbill) {
   const raw = new _bignumber.default((perbill === null || perbill === void 0 ? void 0 : perbill.toString()) || '0');
   const bnPercent = raw.multipliedBy(new _bignumber.default(100)).div(new _bignumber.default(1000000000));
@@ -131,9 +154,18 @@ class TanssiNativeStakingPoolHandler extends _basePara.default {
   async subscribePoolInfo(callback) {
     let cancel = false;
     const defaultCallback = async () => {
-      const api = await this.substrateApi.isReady;
-      const activeConfig = (await api.api.query.collatorConfiguration.activeConfig()).toPrimitive();
+      const chainApi = await this.substrateApi.isReady;
+      const activeConfig = (await chainApi.api.query.collatorConfiguration.activeConfig()).toPrimitive();
       const maxCollators = activeConfig.maxCollators;
+      const chainsToRewardOpt = await chainApi.api.query.inflationRewards.chainsToReward();
+      const chainsToReward = chainsToRewardOpt.toPrimitive();
+      const rewardsPerBlock = chainsToReward.rewardsPerChain;
+      const formatRewardsPerBlock = (0, _utils2.formatNumber)(rewardsPerBlock, (0, _utils._getAssetDecimals)(this.nativeToken));
+      const candidates = await chainApi.api.query.pooledStaking.sortedEligibleCandidates();
+      const activeCollators = await getActiveCollators(chainApi.api);
+      const decimals = (0, _utils._getAssetDecimals)(this.nativeToken);
+      const apyList = candidates.filter(c => activeCollators.includes(c.candidate.toString())).map(c => calculateCollatorApy(formatRewardsPerBlock, new _bignumber.default(c.stake.toString()), decimals));
+      const totalApy = apyList.length ? _bignumber.default.max(...apyList).toNumber() : 0;
       const data = {
         ...this.baseInfo,
         type: this.type,
@@ -154,7 +186,8 @@ class TanssiNativeStakingPoolHandler extends _basePara.default {
           },
           era: 0,
           eraTime: 6 / 3600,
-          unstakingPeriod: 12
+          unstakingPeriod: 12,
+          totalApy
         }
       };
       if (!cancel) {
@@ -172,10 +205,10 @@ class TanssiNativeStakingPoolHandler extends _basePara.default {
   /* Subscribe pool position */
 
   async subscribePoolPosition(useAddresses, onUpdate) {
-    const substrateApi = this.substrateApi;
-    await substrateApi.isReady;
+    const substrateApi = await this.substrateApi.isReady;
     let cancel = false;
     const intervalIds = [];
+    const activeCollators = await getActiveCollators(substrateApi.api);
     for (const delegator of useAddresses) {
       const fetchAndUpdate = async () => {
         if (cancel) {
@@ -229,7 +262,7 @@ class TanssiNativeStakingPoolHandler extends _basePara.default {
           bnJoiningStake = bnJoiningStake.plus(joining);
           bnCompoundingStake = bnCompoundingStake.plus(autoCompounding);
           bnManualStake = bnManualStake.plus(manualRewards);
-          const [identity] = await (0, _utils.parseIdentity)(this.substrateIdentityApi, candidate);
+          const [identity] = await (0, _utils3.parseIdentity)(this.substrateIdentityApi, candidate);
           nominations.push({
             chain: this.chain,
             status: _types.EarningStatus.EARNING_REWARD,
@@ -240,6 +273,19 @@ class TanssiNativeStakingPoolHandler extends _basePara.default {
             validatorMinStake: '0'
           });
         }
+        let status;
+        if (nominations.length === 0) {
+          status = _types.EarningStatus.NOT_STAKING;
+        } else {
+          const activeCount = nominations.filter(n => activeCollators.includes(n.validatorAddress)).length;
+          if (activeCount === 0) {
+            status = _types.EarningStatus.WAITING;
+          } else if (activeCount < nominations.length) {
+            status = _types.EarningStatus.PARTIALLY_EARNING;
+          } else {
+            status = _types.EarningStatus.EARNING_REWARD;
+          }
+        }
         onUpdate({
           ...this.baseInfo,
           type: this.type,
@@ -248,7 +294,7 @@ class TanssiNativeStakingPoolHandler extends _basePara.default {
           totalStake: bnTotalStake.toString(),
           activeStake: bnActiveStake.toString(),
           unstakeBalance: bnUnstakeBalance.toString(),
-          status: nominations.length > 0 ? _types.EarningStatus.EARNING_REWARD : _types.EarningStatus.NOT_STAKING,
+          status,
           isBondedBefore: nominations.length > 0,
           nominations,
           unstakings: [],
@@ -300,6 +346,11 @@ class TanssiNativeStakingPoolHandler extends _basePara.default {
       candidateSummariesMap[address] = summary.toJSON();
     });
     const candidateAddresses = candidates.map(c => c.candidate.toString());
+    const activeCollators = await getActiveCollators(chainApi.api);
+    const chainsToRewardOpt = await chainApi.api.query.inflationRewards.chainsToReward();
+    const chainsToReward = chainsToRewardOpt.toPrimitive();
+    const rewardsPerBlock = chainsToReward.rewardsPerChain;
+    const formatRewardsPerBlock = (0, _utils2.formatNumber)(rewardsPerBlock, (0, _utils._getAssetDecimals)(this.nativeToken));
     const targets = await Promise.all(candidates.map(async c => {
       const address = c.candidate.toString();
       const totalStake = new _bignumber.default(c.stake.toString());
@@ -309,7 +360,11 @@ class TanssiNativeStakingPoolHandler extends _basePara.default {
       const ownStakeInfo = ownStakesMap[address];
       const ownStake = ownStakeInfo ? new _bignumber.default(ownStakeInfo.totalStake) : new _bignumber.default(0);
       const otherStake = _bignumber.default.max(totalStake.minus(ownStake), 0);
-      const [identity, isReasonable] = await (0, _utils.parseIdentity)(this.substrateApi, address);
+      const [identity, isReasonable] = await (0, _utils3.parseIdentity)(this.substrateApi, address);
+      let apy = new _bignumber.default(0);
+      if (activeCollators.includes(address)) {
+        apy = calculateCollatorApy(formatRewardsPerBlock, totalStake, (0, _utils._getAssetDecimals)(this.nativeToken));
+      }
       const validator = {
         address,
         chain: this.chain,
@@ -322,6 +377,7 @@ class TanssiNativeStakingPoolHandler extends _basePara.default {
         blocked: false,
         isVerified: isReasonable,
         isCrowded: false,
+        expectedReturn: apy.toNumber(),
         identity
       };
       return validator;

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

@@ -0,0 +1,21 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class DeleteEarningData20251105 extends _Base.default {
+  async run() {
+    try {
+      await this.state.dbService.deleteYieldPoolInfo(['DOT___native_staking___polkadot', 'DOT___nomination_pool___polkadot']);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+exports.default = DeleteEarningData20251105;

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

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _Base = _interopRequireDefault(require("@subwallet/extension-base/services/migration-service/Base"));
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class MigrateTransactionHistoryBySymbol20251107 extends _Base.default {
+  async run() {
+    const state = this.state;
+    try {
+      const changeSlugsMap = {
+        'bittensor-LOCAL-ف': 'bittensor-LOCAL-ㄴ'
+      };
+      const allTxs = [];
+      await Promise.all(Object.entries(changeSlugsMap).map(async (_ref, i) => {
+        let [oldSlug, newSlug] = _ref;
+        const oldSlugSplit = oldSlug.split('-');
+        const oldChainSlug = oldSlugSplit[0];
+        const oldSymbolSlug = oldSlugSplit[2];
+        const newSlugSplit = newSlug.split('-');
+        const newSymbolSlug = newSlugSplit[2];
+        const filterTransactions = await state.dbService.stores.transaction.table.where({
+          chain: oldChainSlug
+        }).and(tx => {
+          var _tx$amount;
+          return ((_tx$amount = tx.amount) === null || _tx$amount === void 0 ? void 0 : _tx$amount.symbol) === oldSymbolSlug;
+        }).toArray();
+        if (filterTransactions.length > 0) {
+          for (const transaction of filterTransactions) {
+            if (transaction.amount && transaction.amount.symbol === oldSymbolSlug) {
+              transaction.amount.symbol = newSymbolSlug;
+            }
+            if (transaction.fee && transaction.fee.symbol === oldSymbolSlug) {
+              transaction.fee.symbol = newSymbolSlug;
+            }
+          }
+        }
+        allTxs.push(...filterTransactions);
+      }));
+      await state.dbService.stores.transaction.table.bulkPut(allTxs);
+    } catch (e) {
+      this.logger.error(e);
+    }
+  }
+}
+exports.default = MigrateTransactionHistoryBySymbol20251107;