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

package/services/balance-service/index.js

@@ -7,7 +7,7 @@ import { ALL_ACCOUNT_KEY } from '@subwallet/extension-base/constants';
 import { _isXcmWithinSameConsensus } from '@subwallet/extension-base/core/substrate/xcm-parser';
 import { getAcrossbridgeTransferProcessFromEvm, getDefaultTransferProcess, getSnowbridgeTransferProcessFromEvm } from '@subwallet/extension-base/services/balance-service/helpers/process';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
-import { _getChainNativeTokenSlug, _isNativeToken, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
+import { _getChainNativeTokenSlug, _isCustomAsset, _isNativeToken, _isPureEvmChain } from '@subwallet/extension-base/services/chain-service/utils';
 import DetectAccountBalanceStore from '@subwallet/extension-base/stores/DetectAccountBalance';
 import { addLazy, createPromiseHandler, isAccountAll, waitTimeout } from '@subwallet/extension-base/utils';
 import { getKeypairTypeByAddress } from '@subwallet/keyring';
@@ -32,13 +32,14 @@ export class BalanceService {
   stopPromiseHandler = createPromiseHandler();
   status = ServiceStatus.NOT_INITIALIZED;
   isReload = false;
+  requireOptimizeTokenList = false;
   get isStarted() {
     return this.status === ServiceStatus.STARTED;
   }
   detectAccountBalanceStore = new DetectAccountBalanceStore();
   balanceDetectSubject = new 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
@@ -90,6 +91,10 @@ export class BalanceService {
     this.stopPromiseHandler = createPromiseHandler();
     this.status = ServiceStatus.STARTED;
     this.startPromiseHandler.resolve();
+    if (this.requireOptimizeTokenList) {
+      await this.optimizeEnableTokens();
+      this.requireOptimizeTokenList = false;
+    }
   }
 
   /** Stop service */
@@ -447,18 +452,12 @@ export class BalanceService {
       const type = getKeypairTypeByAddress(address);
       const typeValid = [...EthereumKeypairTypes].includes(type);
       if (typeValid) {
-        return new Promise(resolve => {
-          const timeOutPromise = new Promise(_resolve => {
-            setTimeout(() => _resolve([]), 30000);
-          });
-          const balanceDetectionApi = subwalletApiSdk.balanceDetectionApi || Promise.resolve([]);
-          Promise.race([timeOutPromise, balanceDetectionApi.getEvmTokenBalanceSlug(address)]).then(result => resolve(result)).catch(error => {
-            console.error(error);
-            resolve(null);
-          });
+        return subwalletApiSdk.balanceDetectionApi.getSubWalletTokenBalance(address).catch(e => {
+          console.error(e);
+          return null;
         });
       } else {
-        return Promise.resolve(null);
+        return null;
       }
     });
     const needEnableChains = [];
@@ -516,13 +515,13 @@ export 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;
           }
@@ -628,4 +627,146 @@ export class BalanceService {
     }
     return getDefaultTransferProcess();
   }
+
+  // only evm addresses
+  async evmDetectBalanceToken(addresses) {
+    const assetMap = this.state.chainService.getAssetRegistry();
+    const evmPromiseList = addresses.map(address => {
+      return subwalletApiSdk.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 subwalletApiSdk.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 = keyring.getPairs().map(account => account.address);
+      const evmAddresses = addresses.filter(address => [...EthereumKeypairTypes].includes(getKeypairTypeByAddress(address)));
+      const substrateAddresses = addresses.filter(address => [...SubstrateKeypairTypes].includes(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(([tokenSlug, setting]) => {
+        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 && !_isNativeToken(assetInfo) && !_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 **/
 }

package/services/balance-service/transfer/xcm/acrossBridge/index.d.ts

@@ -1,3 +1,4 @@
+import { _ChainAsset, _ChainInfo } from '@subwallet/chain-list/types';
 import { CreateXcmExtrinsicProps } from '..';
 export declare function _isAcrossChainBridge(srcChain: string, destChain: string): boolean;
 export declare function _isAcrossTestnetBridge(srcChain: string): boolean;
@@ -13,4 +14,5 @@ interface XcmApiResponse {
     metadata?: any;
 }
 export declare const getAcrossQuote: ({ destinationChain, destinationTokenInfo, originChain, originTokenInfo, recipient, sender, sendingValue }: CreateXcmExtrinsicProps) => Promise<XcmApiResponse>;
+export declare const getAcrossSendingValue: (originChain: _ChainInfo, originTokenInfo: _ChainAsset, destinationChain: _ChainInfo, isTestnet: boolean) => Promise<string>;
 export {};

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

@@ -2,12 +2,16 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { _isAcrossBridgeXcm } from '@subwallet/extension-base/core/substrate/xcm-parser';
+import { _getAssetDecimals, _getContractAddressOfToken, _getEvmChainId } from '@subwallet/extension-base/services/chain-service/utils';
+import { BasicTxErrorType } from '@subwallet/extension-base/types';
 import subwalletApiSdk from '@subwallet-monorepos/subwallet-services-sdk';
+import BigN from 'bignumber.js';
 // Across Bridge
 const acrossPairsMap = new Map([[COMMON_CHAIN_SLUGS.ETHEREUM, new Set(['optimism', 'base_mainnet', 'arbitrum_one'])], ['optimism', new Set([COMMON_CHAIN_SLUGS.ETHEREUM, 'base_mainnet', 'arbitrum_one'])], ['base_mainnet', new Set([COMMON_CHAIN_SLUGS.ETHEREUM, 'optimism', 'arbitrum_one'])], ['arbitrum_one', new Set([COMMON_CHAIN_SLUGS.ETHEREUM, 'optimism', 'base_mainnet'])], [COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA, new Set(['base_sepolia', 'arbitrum_sepolia'])],
 // TESTNET START HERE
-['base_sepolia', new Set([COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA])], ['arbitrum_sepolia', new Set([COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA])]]);
+['base_sepolia', new Set([COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA, 'arbitrum_sepolia'])], ['arbitrum_sepolia', new Set([COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA, 'base_sepolia'])]]);
 export 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;
@@ -33,7 +37,7 @@ export const getAcrossQuote = async ({
     throw new Error('Sender is required');
   }
   try {
-    const data = await subwalletApiSdk.xcmApi.fetchXcmData({
+    const data = await subwalletApiSdk.bridgeApi.fetchBridgeData({
       address: sender,
       from: originTokenInfo.slug,
       to: destinationTokenInfo.slug,
@@ -50,4 +54,45 @@ export const getAcrossQuote = async ({
     }
     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'));
   }
+};
+
+// TODO: update logic after add across metadata for chainlist
+const acrossNativeTokenAddresses = {
+  mainnet: {
+    arbitrum_one: '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1',
+    base_mainnet: '0x4200000000000000000000000000000000000006',
+    ethereum: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+    optimism: '0x4200000000000000000000000000000000000006'
+  },
+  testnet: {
+    arbitrum_sepolia: '0x980B62Da83eFf3D4576C647993b0c1D7faf17c73',
+    base_sepolia: '0x4200000000000000000000000000000000000006',
+    sepolia_ethereum: '0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14'
+  }
+};
+export const getAcrossSendingValue = async (originChain, originTokenInfo, destinationChain, isTestnet) => {
+  try {
+    const originChainId = _getEvmChainId(originChain);
+    const destinationChainId = _getEvmChainId(destinationChain);
+    if (!originChainId || !destinationChainId) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
+    }
+    const contracts = isTestnet ? acrossNativeTokenAddresses.testnet : acrossNativeTokenAddresses.mainnet;
+    const fromContract = _getContractAddressOfToken(originTokenInfo) || contracts[originTokenInfo.originChain];
+    const acrossBridgeLimit = await subwalletApiSdk.bridgeApi.getAcrossBridgeLimit(originChainId, destinationChainId, fromContract, isTestnet);
+    if (!acrossBridgeLimit.minDeposit || !acrossBridgeLimit.maxDeposit) {
+      throw new Error('Invalid Across Bridge response');
+    }
+    const min = new BigN(acrossBridgeLimit.minDeposit);
+    const max = new BigN(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 BigN(defaultSendingAmount).shiftedBy(_getAssetDecimals(originTokenInfo)).toFixed(0, BigN.ROUND_FLOOR);
+  }
 };

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

@@ -181,7 +181,7 @@ export const createAcrossBridgeExtrinsic = async ({
     throw new Error('Sender is required');
   }
   try {
-    const data = await subwalletApiSdk.xcmApi.fetchXcmData({
+    const data = await subwalletApiSdk.bridgeApi.fetchBridgeData({
       address: sender,
       from: originTokenInfo.slug,
       to: destinationTokenInfo.slug,
@@ -204,9 +204,14 @@ export const createAcrossBridgeExtrinsic = async ({
     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));
   }
 };

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

@@ -268,9 +268,6 @@ export 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/services/chain-service/index.d.ts

@@ -121,6 +121,7 @@ export declare class ChainService {
     stopCheckLatestChainData(): void;
     handleLatestChainData(latestChainInfo: _ChainInfo[]): void;
     autoEnableTokens(): Promise<void>;
+    resetPopularTokenList(): void;
     enablePopularTokens(): Promise<void>;
     handleLatestLedgerGenericAllowChains(latestledgerGenericAllowChains: string[]): void;
     handleLatestPriorityTokens(latestPriorityTokens: TokenPriorityDetails): void;

package/services/chain-service/index.js

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

package/services/chain-service/utils/patch.d.ts

@@ -1,5 +1,5 @@
 import { _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
-export declare const ChainListVersion = "0.2.119";
+export declare const ChainListVersion = "0.2.120";
 export interface PatchInfo {
     patchVersion: string;
     appliedVersion: string;

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

@@ -5,7 +5,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';
-export const ChainListVersion = '0.2.119'; // update this when build chain-list
+export const ChainListVersion = '0.2.120'; // update this when build chain-list
 
 // todo: move this interface to chainlist
 

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

@@ -32,8 +32,6 @@ export const MANTA_VALIDATOR_POINTS_PER_BLOCK = 20;
 export const MANTA_MIN_DELEGATION = 500;
 export const CHANNEL_ID = 7;
 export const STAKING_IDENTITY_API_SLUG = {
-  // @TODO: Remove polkadot then migrate
-  polkadot: 'polkadot_people',
   statemine: 'peopleKusama',
   statemint: 'polkadot_people'
 };

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

@@ -8,6 +8,8 @@ import { BasicTxErrorType, EarningStatus, YieldStepType } from '@subwallet/exten
 import { BN, BN_TEN, BN_ZERO } from '@polkadot/util';
 import { fakeAddress } from "../../constants/index.js";
 import BaseLendingPoolHandler from "./base.js";
+
+// TODO: disable earning and stake actions but keep showing existing earning positions (currently handle on UI)
 export default class InterlayLendingPoolHandler extends BaseLendingPoolHandler {
   altInputAsset = 'polkadot-NATIVE-DOT';
   derivativeAssets = ['interlay-LOCAL-qDOT'];

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

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

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

@@ -14,7 +14,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}}';
 export default class BifrostLiquidStakingPoolHandler extends BaseLiquidStakingPoolHandler {
-  altInputAsset = 'polkadot-NATIVE-DOT';
+  altInputAsset = 'statemint-NATIVE-DOT';
   derivativeAssets = ['bifrost_dot-LOCAL-vDOT'];
   inputAsset = 'bifrost_dot-LOCAL-DOT';
   rewardAssets = ['bifrost_dot-LOCAL-DOT'];

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

@@ -8,6 +8,8 @@ import { fakeAddress } from '@subwallet/extension-base/services/earning-service/
 import { EarningStatus, UnstakingStatus, YieldStepType } from '@subwallet/extension-base/types';
 import { BN, BN_TEN, BN_ZERO } from '@polkadot/util';
 import BaseLiquidStakingPoolHandler from "./base.js";
+
+// TODO: disable earning and stake actions but keep showing existing earning positions (currently handle on UI)
 export default class ParallelLiquidStakingPoolHandler extends BaseLiquidStakingPoolHandler {
   altInputAsset = 'polkadot-NATIVE-DOT';
   derivativeAssets = ['parallel-LOCAL-sDOT'];

package/services/earning-service/handlers/native-staking/energy.d.ts

@@ -16,6 +16,12 @@ export interface PalletEnergyStakingNominationRequestsScheduledRequest {
     whenExecutable: number;
     action: Record<PalletParachainStakingRequestType, number>;
 }
+export interface PalletEnergyStakingTopNominations {
+    nominations: Array<{
+        owner: string;
+        amount: string;
+    }>;
+}
 export default class EnergyNativeStakingPoolHandler extends BaseParaNativeStakingPoolHandler {
     subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
     parseNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi, nominatorState: PalletEnergyStakingNominator): Promise<Omit<YieldPositionInfo, keyof BaseYieldPositionInfo>>;

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

@@ -3,13 +3,16 @@
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
-import { getBondedValidators, getEarningStatusByNominations, isUnstakeAll } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import { calculateEnergyWebCollatorReturn, getBondedValidators, getEarningStatusByNominations, isUnstakeAll } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
 import { _EXPECTED_BLOCK_TIME, _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
 import { parseIdentity } from '@subwallet/extension-base/services/earning-service/utils';
 import { BasicTxErrorType, EarningStatus, UnstakingStatus } from '@subwallet/extension-base/types';
 import { balanceFormatter, formatNumber, parseRawNumber, reformatAddress } from '@subwallet/extension-base/utils';
-import { BN, BN_ZERO } from '@polkadot/util';
+import { BN, BN_TEN, BN_ZERO } from '@polkadot/util';
 import BaseParaNativeStakingPoolHandler from "./base-para.js";
+const DEFAULT_ANNUAL_REWARD = {
+  energy_web_x: 2000000
+};
 export default class EnergyNativeStakingPoolHandler extends BaseParaNativeStakingPoolHandler {
   /* Subscribe pool info */
 
@@ -53,6 +56,13 @@ export default class EnergyNativeStakingPoolHandler extends BaseParaNativeStakin
       const unstakingPeriod = parseInt(unstakingDelay.toString()) * eraTime;
       const minStake = '0';
       const minToHuman = formatNumber(minStake.toString(), nativeToken.decimals || 0, 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,
@@ -76,8 +86,7 @@ export default class EnergyNativeStakingPoolHandler extends BaseParaNativeStakin
           // TODO recheck
           era,
           eraTime,
-          totalApy: undefined,
-          // not have
+          totalApy: maxApy,
           tvl: totalStake.toString(),
           unstakingPeriod: unstakingPeriod
         },
@@ -250,12 +259,21 @@ export default class EnergyNativeStakingPoolHandler extends BaseParaNativeStakin
     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];
@@ -282,6 +300,39 @@ export default class EnergyNativeStakingPoolHandler extends BaseParaNativeStakin
         });
       }
     }
+    const annualReward = DEFAULT_ANNUAL_REWARD[this.chain] ? new BN(DEFAULT_ANNUAL_REWARD[this.chain]).mul(BN_TEN.pow(new BN(this.nativeToken.decimals || 18))) : BN_ZERO;
+
+    // calculate expected return
+    await Promise.all(allCollators.map(async collator => {
+      if (!selectedCollators.includes(collator.address) || annualReward.lte(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, {
+        amount,
+        owner
+      }) => {
+        record[owner] = amount || '0';
+        return record;
+      }, {});
+      let bnTotalActiveStake = new BN(collator.totalStake);
+      if (nominationScheduledRequests !== null && nominationScheduledRequests !== void 0 && nominationScheduledRequests.length) {
+        const bnTotalInactiveStake = nominationScheduledRequests.reduce((partialSum, {
+          action,
+          nominator,
+          whenExecutable
+        }) => {
+          if (whenExecutable + delay - parseInt(currentRound) < 0 && action) {
+            return partialSum.add(new BN(topNominationsRecord[nominator] || Object.values(action)[0] || BN_ZERO));
+          }
+          return partialSum;
+        }, BN_ZERO);
+        bnTotalActiveStake = bnTotalActiveStake.sub(bnTotalInactiveStake);
+      }
+      collator.expectedReturn = 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), parseIdentity(substrateIdentityApi, collator.address)]);
@@ -297,6 +348,7 @@ export default class EnergyNativeStakingPoolHandler extends BaseParaNativeStakin
       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/services/earning-service/handlers/native-staking/relay-chain.js

@@ -60,10 +60,7 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
       }
       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 getRelayMaxNominations(substrateApi, this.chain);
+      const maxNominations = await getRelayMaxNominations(substrateApi, this.chain);
       const currentEra = _currentEra.toString();
       const maxUnlockingChunks = substrateApi.api.consts.staking.maxUnlockingChunks.toString();
       const unlockingEras = substrateApi.api.consts.staking.bondingDuration.toString();