@subwallet/extension-base 1.1.32-beta.0 → 1.1.33-beta.0

package/koni/background/handlers/Tabs.js

@@ -13,7 +13,7 @@ import { PHISHING_PAGE_REDIRECT } from '@subwallet/extension-base/defaults';
 import { _CHAIN_VALIDATION_ERROR } from '@subwallet/extension-base/services/chain-service/handler/types';
 import { _generateCustomProviderKey } from '@subwallet/extension-base/services/chain-service/utils';
 import { DEFAULT_CHAIN_PATROL_ENABLE } from '@subwallet/extension-base/services/setting-service/constants';
-import { canDerive, stripUrl } from '@subwallet/extension-base/utils';
+import { canDerive, getEVMChainInfo, stripUrl } from '@subwallet/extension-base/utils';
 import keyring from '@subwallet/ui-keyring';
 import { t } from 'i18next';
 import Web3 from 'web3';
@@ -382,15 +382,32 @@ export default class KoniTabs {
   }) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
     const chainId = params[0].chainId;
+    const chainIdDec = parseInt(chainId, 16);
     const evmState = await this.getEvmState(url);
     if (evmState.chainId === chainId) {
       return null;
     }
-    const [networkKey] = this.#koniState.findNetworkKeyByChainId(parseInt(chainId, 16));
+    const [networkKey] = this.#koniState.findNetworkKeyByChainId(chainIdDec);
     if (networkKey) {
       await this.#koniState.switchEvmNetworkByUrl(stripUrl(url), networkKey);
     } else {
-      throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'This network is currently not supported');
+      const onlineData = await getEVMChainInfo(chainIdDec);
+      if (onlineData) {
+        const chainData = {
+          chainId: chainId,
+          rpcUrls: onlineData.rpc.filter(url => url.startsWith('https://')),
+          chainName: onlineData.name,
+          blockExplorerUrls: onlineData.explorers.map(explorer => explorer.url),
+          nativeCurrency: onlineData.nativeCurrency,
+          requestId: id
+        };
+        await this.addEvmChain(id, url, {
+          method: 'wallet_addEthereumChain',
+          params: [chainData]
+        });
+      } else {
+        throw new EvmProviderError(EvmProviderErrorType.INVALID_PARAMS, 'This network is currently not supported');
+      }
     }
     return null;
   }

package/package.json

@@ -17,7 +17,7 @@
     "./cjs/detectPackage.js"
   ],
   "type": "module",
-  "version": "1.1.32-beta.0",
+  "version": "1.1.33-beta.0",
   "main": "./cjs/index.js",
   "module": "./index.js",
   "types": "./index.d.ts",
@@ -1620,6 +1620,11 @@
       "require": "./cjs/utils/eth/parseTransaction/base.js",
       "default": "./utils/eth/parseTransaction/base.js"
     },
+    "./utils/fetchEvmChainInfo": {
+      "types": "./utils/fetchEvmChainInfo.d.ts",
+      "require": "./cjs/utils/fetchEvmChainInfo.js",
+      "default": "./utils/fetchEvmChainInfo.js"
+    },
     "./utils/fetchStaticData": {
       "types": "./utils/fetchStaticData.d.ts",
       "require": "./cjs/utils/fetchStaticData.js",
@@ -1706,11 +1711,11 @@
     "@reduxjs/toolkit": "^1.9.1",
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.7.26",
-    "@subwallet/chain-list": "0.2.38",
-    "@subwallet/extension-base": "^1.1.32-0",
-    "@subwallet/extension-chains": "^1.1.32-0",
-    "@subwallet/extension-dapp": "^1.1.32-0",
-    "@subwallet/extension-inject": "^1.1.32-0",
+    "@subwallet/chain-list": "0.2.39",
+    "@subwallet/extension-base": "^1.1.33-0",
+    "@subwallet/extension-chains": "^1.1.33-0",
+    "@subwallet/extension-dapp": "^1.1.33-0",
+    "@subwallet/extension-inject": "^1.1.33-0",
     "@subwallet/keyring": "^0.1.1",
     "@subwallet/ui-keyring": "^0.1.1",
     "@walletconnect/sign-client": "^2.8.4",

package/packageInfo.js

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

package/services/chain-service/constants.js

@@ -29,7 +29,7 @@ export const _BALANCE_CHAIN_GROUP = {
   genshiro: ['genshiro_testnet', 'genshiro'],
   equilibrium_parachain: ['equilibrium_parachain'],
   bifrost: ['bifrost', 'acala', 'karura', 'acala_testnet', 'pioneer', 'bitcountry', 'bifrost_dot', 'hydradx_main', 'pendulum', 'amplitude'],
-  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel', 'calamari'],
+  statemine: ['statemine', 'astar', 'shiden', 'statemint', 'moonbeam', 'moonbase', 'moonriver', 'crabParachain', 'darwinia2', 'parallel', 'calamari', 'manta_network'],
   kusama: ['kusama', 'kintsugi', 'kintsugi_test', 'interlay', 'acala', 'statemint', 'karura', 'bifrost'],
   // perhaps there are some runtime updates
   centrifuge: ['centrifuge']
@@ -84,7 +84,8 @@ export const _STAKING_ERA_LENGTH_MAP = {
   creditcoin: 24,
   vara_network: 12,
   goldberg_testnet: 24,
-  manta_network: 6
+  manta_network: 6,
+  krest_network: 4
 };
 export const _EXPECTED_BLOCK_TIME = {
   // in seconds

package/services/earning-service/constants/chains.d.ts

@@ -10,5 +10,6 @@ export declare const _STAKING_CHAIN_GROUP: {
     ternoa: string[];
     liquidStaking: string[];
     lending: string[];
+    krest_network: string[];
 };
 export declare const ST_LIQUID_TOKEN_ABI: Record<string, any>;

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

@@ -5,7 +5,7 @@ export const _STAKING_CHAIN_GROUP = {
   relay: ['polkadot', 'kusama', 'aleph', 'polkadex', 'ternoa', 'ternoa_alphanet', 'alephTest', 'polkadexTest', 'westend', 'kate', 'edgeware', 'creditcoin', 'vara_network', 'goldberg_testnet'],
   para: ['moonbeam', 'moonriver', 'moonbase', 'turing', 'turingStaging', 'bifrost', 'bifrost_testnet', 'calamari_test', 'calamari', 'manta_network'],
   astar: ['astar', 'shiden', 'shibuya'],
-  amplitude: ['amplitude', 'amplitude_test', 'kilt', 'kilt_peregrine', 'pendulum'],
+  amplitude: ['amplitude', 'amplitude_test', 'kilt', 'kilt_peregrine', 'pendulum', 'krest_network'],
   // amplitude and kilt only share some common logic
   kilt: ['kilt', 'kilt_peregrine'],
   nominationPool: ['polkadot', 'kusama', 'westend', 'alephTest', 'aleph', 'kate', 'vara_network', 'goldberg_testnet'],
@@ -14,7 +14,8 @@ export const _STAKING_CHAIN_GROUP = {
   // A0 has distinct tokenomics
   ternoa: ['ternoa', 'ternoa_alphanet'],
   liquidStaking: ['bifrost_dot', 'acala', 'parallel', 'moonbeam'],
-  lending: ['interlay']
+  lending: ['interlay'],
+  krest_network: ['krest_network']
 };
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-unsafe-assignment

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

@@ -237,7 +237,7 @@ export default class BifrostLiquidStakingPoolHandler extends BaseLiquidStakingPo
     const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
     const defaultFeeTokenSlug = this.feeAssets[0];
     if (new BN(params.amount).gt(BN_ZERO)) {
-      const _mintFeeInfo = await poolOriginSubstrateApi.api.tx.vtokenMinting.mint(_getTokenOnChainInfo(inputTokenInfo), params.amount, null).paymentInfo(fakeAddress);
+      const _mintFeeInfo = await poolOriginSubstrateApi.api.tx.vtokenMinting.mint(_getTokenOnChainInfo(inputTokenInfo), params.amount, undefined, undefined).paymentInfo(fakeAddress);
       const mintFeeInfo = _mintFeeInfo.toPrimitive();
       return {
         amount: mintFeeInfo.partialFee.toString(),
@@ -254,7 +254,7 @@ export default class BifrostLiquidStakingPoolHandler extends BaseLiquidStakingPo
     const substrateApi = await this.substrateApi.isReady;
     const inputTokenSlug = this.inputAsset;
     const inputTokenInfo = this.state.getAssetBySlug(inputTokenSlug);
-    const extrinsic = substrateApi.api.tx.vtokenMinting.mint(_getTokenOnChainInfo(inputTokenInfo), data.amount, undefined);
+    const extrinsic = substrateApi.api.tx.vtokenMinting.mint(_getTokenOnChainInfo(inputTokenInfo), data.amount, undefined, undefined);
     return {
       txChain: this.chain,
       extrinsicType: ExtrinsicType.MINT_VDOT,

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

@@ -6,7 +6,7 @@ import { SubmittableExtrinsic } from '@polkadot/api/types';
 import BaseParaNativeStakingPoolHandler from './base-para';
 export default class AmplitudeNativeStakingPoolHandler extends BaseParaNativeStakingPoolHandler {
     subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
-    parseNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi, delegatorState: ParachainStakingStakeOption, unstakingInfo: Record<string, number>): Promise<Omit<YieldPositionInfo, keyof BaseYieldPositionInfo>>;
+    parseNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi, delegatorState: ParachainStakingStakeOption[], unstakingInfo: Record<string, number>): Promise<Omit<YieldPositionInfo, keyof BaseYieldPositionInfo>>;
     subscribePoolPosition(useAddresses: string[], resultCallback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
     getPoolReward(useAddresses: string[], callBack: (rs: EarningRewardItem) => void): Promise<VoidFunction>;
     getPoolTargets(): Promise<ValidatorInfo[]>;

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

@@ -48,6 +48,7 @@ export default class AmplitudeNativeStakingPoolHandler extends BaseParaNativeSta
       const minDelegatorStake = substrateApi.api.consts.parachainStaking.minDelegatorStake.toString();
       const unstakingDelay = substrateApi.api.consts.parachainStaking.stakeDuration.toString(); // in blocks
       const _blockPerRound = substrateApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
+      const maxUnstakeRequests = substrateApi.api.consts.parachainStaking.maxUnstakeRequests.toPrimitive();
       const blockPerRound = parseFloat(_blockPerRound);
       const roundTime = _STAKING_ERA_LENGTH_MAP[this.chain] || _STAKING_ERA_LENGTH_MAP.default; // in hours
       const blockDuration = roundTime / blockPerRound; // in hours
@@ -68,7 +69,7 @@ export default class AmplitudeNativeStakingPoolHandler extends BaseParaNativeSta
             slug: this.nativeToken.slug
           }],
           maxCandidatePerFarmer: parseInt(maxDelegations),
-          maxWithdrawalRequestPerFarmer: 1,
+          maxWithdrawalRequestPerFarmer: maxUnstakeRequests,
           // by default
           earningThreshold: {
             join: minDelegatorStake,
@@ -102,48 +103,54 @@ export default class AmplitudeNativeStakingPoolHandler extends BaseParaNativeSta
     const nominationList = [];
     const unstakingList = [];
     const minDelegatorStake = substrateApi.api.consts.parachainStaking.minDelegatorStake.toString();
+    const hasUnstakingInfo = unstakingInfo && Object.values(unstakingInfo).length > 0;
     let activeStake = '0';
     let unstakingBalance = '0';
     if (delegatorState) {
       // delegatorState can be null while unstaking all
-      const [identity] = await parseIdentity(substrateApi, delegatorState.owner);
-      activeStake = delegatorState.amount.toString();
-      const bnActiveStake = new BN(activeStake);
-      let delegationStatus = EarningStatus.NOT_EARNING;
-      if (bnActiveStake.gt(BN_ZERO) && bnActiveStake.gte(new BN(minDelegatorStake))) {
-        delegationStatus = EarningStatus.EARNING_REWARD;
+      const identityPromises = delegatorState.map(delegate => parseIdentity(substrateApi, delegate.owner));
+      const identities = await Promise.all(identityPromises);
+      for (let i = 0; i < delegatorState.length; i++) {
+        const delegate = delegatorState[i];
+        const [identity] = identities[i];
+        activeStake = delegate.amount.toString();
+        const bnActiveStake = new BN(activeStake);
+        let delegationStatus = EarningStatus.NOT_EARNING;
+        if (bnActiveStake.gt(BN_ZERO) && bnActiveStake.gte(new BN(minDelegatorStake))) {
+          delegationStatus = EarningStatus.EARNING_REWARD;
+        }
+        nominationList.push({
+          status: delegationStatus,
+          chain: chainInfo.slug,
+          validatorAddress: delegate.owner,
+          activeStake: delegate.amount.toString(),
+          validatorMinStake: '0',
+          hasUnstaking: hasUnstakingInfo,
+          validatorIdentity: identity
+        });
       }
-      nominationList.push({
-        status: delegationStatus,
-        chain: chainInfo.slug,
-        validatorAddress: delegatorState.owner,
-        activeStake: delegatorState.amount.toString(),
-        validatorMinStake: '0',
-        hasUnstaking: !!unstakingInfo && Object.values(unstakingInfo).length > 0,
-        validatorIdentity: identity
-      });
-    }
-    if (unstakingInfo && Object.values(unstakingInfo).length > 0) {
-      const _currentBlockInfo = await substrateApi.api.rpc.chain.getHeader();
-      const currentBlockInfo = _currentBlockInfo.toPrimitive();
-      const currentBlockNumber = currentBlockInfo.number;
-      const _blockPerRound = substrateApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
-      const blockPerRound = parseFloat(_blockPerRound);
-      const nearestUnstakingBlock = Object.keys(unstakingInfo)[0];
-      const nearestUnstakingAmount = Object.values(unstakingInfo)[0];
-      const blockDuration = (_STAKING_ERA_LENGTH_MAP[chainInfo.slug] || _STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
+      if (hasUnstakingInfo) {
+        const _currentBlockInfo = await substrateApi.api.rpc.chain.getHeader();
+        const currentBlockInfo = _currentBlockInfo.toPrimitive();
+        const currentBlockNumber = currentBlockInfo.number;
+        const _blockPerRound = substrateApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
+        const blockPerRound = parseFloat(_blockPerRound);
+        for (const [unstakingBlock, unstakingAmount] of Object.entries(unstakingInfo)) {
+          const blockDuration = (_STAKING_ERA_LENGTH_MAP[chainInfo.slug] || _STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
 
-      const isClaimable = parseInt(nearestUnstakingBlock) - currentBlockNumber < 0;
-      const remainingBlock = parseInt(nearestUnstakingBlock) - currentBlockNumber;
-      const waitingTime = remainingBlock * blockDuration;
-      unstakingBalance = nearestUnstakingAmount.toString();
-      unstakingList.push({
-        chain: chainInfo.slug,
-        status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
-        claimable: nearestUnstakingAmount.toString(),
-        waitingTime,
-        validatorAddress: (delegatorState === null || delegatorState === void 0 ? void 0 : delegatorState.owner) || undefined
-      });
+          const isClaimable = parseInt(unstakingBlock) - currentBlockNumber < 0;
+          const remainingBlock = parseInt(unstakingBlock) - currentBlockNumber;
+          const waitingTime = remainingBlock * blockDuration;
+          unstakingBalance = unstakingAmount.toString();
+          unstakingList.push({
+            chain: chainInfo.slug,
+            status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
+            claimable: unstakingAmount.toString(),
+            waitingTime,
+            validatorAddress: undefined
+          });
+        }
+      }
     }
     const totalBalance = new BN(activeStake).add(new BN(unstakingBalance));
     const stakingStatus = getEarningStatusByNominations(new BN(activeStake), nominationList);
@@ -172,8 +179,20 @@ export default class AmplitudeNativeStakingPoolHandler extends BaseParaNativeSta
         const _unstakingStates = await substrateApi.api.query.parachainStaking.unstaking.multi(useAddresses);
         await Promise.all(ledgers.map(async (_delegatorState, i) => {
           const owner = reformatAddress(useAddresses[i], 42);
-          const delegatorState = _delegatorState.toPrimitive();
+          let delegatorState = [];
           const unstakingInfo = _unstakingStates[i].toPrimitive();
+          if (_STAKING_CHAIN_GROUP.krest_network.includes(this.chain)) {
+            const krestDelegatorState = _delegatorState.toPrimitive();
+            const delegates = krestDelegatorState === null || krestDelegatorState === void 0 ? void 0 : krestDelegatorState.delegations;
+            if (delegates) {
+              delegatorState = delegatorState.concat(delegates);
+            }
+          } else {
+            const delegate = _delegatorState.toPrimitive();
+            if (delegate) {
+              delegatorState.push(delegate);
+            }
+          }
           if (!delegatorState && !unstakingInfo) {
             resultCallback({
               ...defaultInfo,
@@ -214,7 +233,7 @@ export default class AmplitudeNativeStakingPoolHandler extends BaseParaNativeSta
     let cancel = false;
     const substrateApi = this.substrateApi;
     await substrateApi.isReady;
-    if (!_STAKING_CHAIN_GROUP.kilt.includes(this.chain)) {
+    if (!_STAKING_CHAIN_GROUP.kilt.includes(this.chain) && !_STAKING_CHAIN_GROUP.krest_network.includes(this.chain)) {
       await Promise.all(useAddresses.map(async address => {
         const _unclaimedReward = await substrateApi.api.query.parachainStaking.rewards(address);
         if (cancel) {
@@ -240,33 +259,59 @@ export default class AmplitudeNativeStakingPoolHandler extends BaseParaNativeSta
 
   async getPoolTargets() {
     const chainApi = await this.substrateApi.isReady;
-    const [_allCollators, _inflationConfig] = await Promise.all([chainApi.api.query.parachainStaking.candidatePool.entries(), chainApi.api.query.parachainStaking.inflationConfig()]);
-    const maxDelegatorsPerCollator = chainApi.api.consts.parachainStaking.maxDelegatorsPerCollator.toString();
-    const inflationConfig = _inflationConfig.toHuman();
-    const rawDelegatorReturn = inflationConfig.delegator.rewardRate.annual;
-    const delegatorReturn = parseFloat(rawDelegatorReturn.split('%')[0]);
-    const allCollators = [];
-    for (const _collator of _allCollators) {
-      const collatorInfo = _collator[1].toPrimitive();
-      const bnTotalStake = new BN(collatorInfo.total);
-      const bnOwnStake = new BN(collatorInfo.stake);
-      const bnOtherStake = bnTotalStake.sub(bnOwnStake);
-      allCollators.push({
-        address: collatorInfo.id,
-        totalStake: bnTotalStake.toString(),
-        ownStake: bnOwnStake.toString(),
-        otherStake: bnOtherStake.toString(),
-        nominatorCount: collatorInfo.delegators.length,
-        commission: 0,
-        expectedReturn: delegatorReturn,
-        blocked: false,
-        isVerified: false,
-        minBond: '0',
-        chain: this.chain,
-        isCrowded: collatorInfo.delegators.length >= parseInt(maxDelegatorsPerCollator)
-      });
+    if (_STAKING_CHAIN_GROUP.krest_network.includes(this.chain)) {
+      const _allCollators = await chainApi.api.query.parachainStaking.candidatePool.entries();
+      const maxDelegatorsPerCollator = chainApi.api.consts.parachainStaking.maxDelegatorsPerCollator.toString();
+      const allCollators = [];
+      for (const _collator of _allCollators) {
+        const collatorInfo = _collator[1].toPrimitive();
+        const bnTotalStake = new BN(collatorInfo.total);
+        const bnOwnStake = new BN(collatorInfo.stake);
+        const bnOtherStake = bnTotalStake.sub(bnOwnStake);
+        allCollators.push({
+          address: collatorInfo.id,
+          totalStake: bnTotalStake.toString(),
+          ownStake: bnOwnStake.toString(),
+          otherStake: bnOtherStake.toString(),
+          nominatorCount: collatorInfo.delegators.length,
+          commission: 0,
+          blocked: false,
+          isVerified: false,
+          minBond: '0',
+          chain: this.chain,
+          isCrowded: collatorInfo.delegators.length >= parseInt(maxDelegatorsPerCollator)
+        });
+      }
+      return allCollators;
+    } else {
+      const [_allCollators, _inflationConfig] = await Promise.all([chainApi.api.query.parachainStaking.candidatePool.entries(), chainApi.api.query.parachainStaking.inflationConfig()]);
+      const maxDelegatorsPerCollator = chainApi.api.consts.parachainStaking.maxDelegatorsPerCollator.toString();
+      const inflationConfig = _inflationConfig.toHuman();
+      const rawDelegatorReturn = inflationConfig.delegator.rewardRate.annual;
+      const delegatorReturn = parseFloat(rawDelegatorReturn.split('%')[0]);
+      const allCollators = [];
+      for (const _collator of _allCollators) {
+        const collatorInfo = _collator[1].toPrimitive();
+        const bnTotalStake = new BN(collatorInfo.total);
+        const bnOwnStake = new BN(collatorInfo.stake);
+        const bnOtherStake = bnTotalStake.sub(bnOwnStake);
+        allCollators.push({
+          address: collatorInfo.id,
+          totalStake: bnTotalStake.toString(),
+          ownStake: bnOwnStake.toString(),
+          otherStake: bnOtherStake.toString(),
+          nominatorCount: collatorInfo.delegators.length,
+          commission: 0,
+          expectedReturn: delegatorReturn,
+          blocked: false,
+          isVerified: false,
+          minBond: '0',
+          chain: this.chain,
+          isCrowded: collatorInfo.delegators.length >= parseInt(maxDelegatorsPerCollator)
+        });
+      }
+      return allCollators;
     }
-    return allCollators;
   }
 
   /* Get pool targets */

package/services/earning-service/service.d.ts

@@ -37,11 +37,12 @@ export default class EarningService implements StoppableServiceInterface, Persis
     getMinAmountPercent(): Record<string, number>;
     getYieldPool(slug: string): Promise<YieldPoolInfo | undefined>;
     subscribePoolsInfo(callback: (rs: YieldPoolInfo) => void): Promise<VoidFunction>;
-    private getYieldPoolInfoFromDBAndOnline;
+    private getYieldPoolInfoFromDB;
     subscribeYieldPoolInfo(): BehaviorSubject<Record<string, YieldPoolInfo>>;
     getYieldPoolInfo(): Promise<YieldPoolInfo[]>;
     private yieldPoolPersistQueue;
     updateYieldPoolInfo(data: YieldPoolInfo): void;
+    private fetchingPoolsInfoOnline;
     private yieldPoolsInfoUnsub;
     runSubscribePoolsInfo(): Promise<void>;
     runUnsubscribePoolsInfo(): void;

package/services/earning-service/service.js

@@ -3,7 +3,7 @@
 
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { BasicTxErrorType } from '@subwallet/extension-base/background/KoniTypes';
-import { CRON_REFRESH_EARNING_REWARD_HISTORY_INTERVAL, CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL } from '@subwallet/extension-base/constants';
+import { CRON_REFRESH_CHAIN_STAKING_METADATA, CRON_REFRESH_EARNING_REWARD_HISTORY_INTERVAL, CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL } from '@subwallet/extension-base/constants';
 import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
 import { _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
 import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/earning-service/constants';
@@ -148,7 +148,7 @@ export default class EarningService {
     });
   }
   async loadData() {
-    await this.getYieldPoolInfoFromDBAndOnline();
+    await this.getYieldPoolInfoFromDB();
     await this.getYieldPositionFromDB();
   }
   persistData() {
@@ -258,18 +258,12 @@ export default class EarningService {
       });
     };
   }
-  async getYieldPoolInfoFromDBAndOnline() {
+  async getYieldPoolInfoFromDB() {
     // Get online pool data
-    const yieldPoolInfo = await Promise.race([fetchPoolsData(), new Promise(resolve => {
-      setTimeout(() => {
-        resolve({});
-      }, 1200);
-    })]);
+    const yieldPoolInfo = {};
     const existedYieldPoolInfo = await this.dbService.getYieldPools();
     existedYieldPoolInfo.forEach(info => {
-      if (!yieldPoolInfo[info.slug]) {
-        yieldPoolInfo[info.slug] = info;
-      }
+      yieldPoolInfo[info.slug] = info;
     });
     this.yieldPoolInfoSubject.next(yieldPoolInfo);
   }
@@ -290,7 +284,11 @@ export default class EarningService {
 
       // Update yield pool info
       queue.forEach(item => {
-        yieldPoolInfo[item.slug] = item;
+        const existed = yieldPoolInfo[item.slug];
+        if (item.statistic && (!(existed !== null && existed !== void 0 && existed.lastUpdated) || existed.lastUpdated < ((item === null || item === void 0 ? void 0 : item.lastUpdated) || 0))) {
+          // Only update item has statistic information
+          yieldPoolInfo[item.slug] = item;
+        }
       });
       this.yieldPoolInfoSubject.next(yieldPoolInfo);
 
@@ -298,13 +296,35 @@ export default class EarningService {
       this.dbService.updateYieldPoolsStore(queue).catch(console.warn);
     }, 300, 900);
   }
+  async fetchingPoolsInfoOnline() {
+    const onlineData = await Promise.race([fetchPoolsData(), new Promise(resolve => {
+      setTimeout(() => {
+        resolve({});
+      }, 1800);
+    })]);
+    Object.values(onlineData).forEach(item => {
+      this.updateYieldPoolInfo(item);
+    });
+  }
   async runSubscribePoolsInfo() {
     await this.eventService.waitChainReady;
     this.runUnsubscribePoolsInfo();
+
+    // Fetching online data
+    await this.fetchingPoolsInfoOnline();
+    const interval = setInterval(() => {
+      this.fetchingPoolsInfoOnline().catch(console.error);
+    }, CRON_REFRESH_CHAIN_STAKING_METADATA);
+
+    // Fetching from chains
     this.subscribePoolsInfo(data => {
+      data.lastUpdated = Date.now();
       this.updateYieldPoolInfo(data);
     }).then(rs => {
-      this.yieldPoolsInfoUnsub = rs;
+      this.yieldPoolsInfoUnsub = () => {
+        rs();
+        clearInterval(interval);
+      };
     }).catch(console.error);
   }
   runUnsubscribePoolsInfo() {

package/services/event-service/types.d.ts

@@ -26,6 +26,7 @@ export interface EventRegistry {
     'asset.updateState': [string];
     'transaction.done': [SWTransaction];
     'transaction.failed': [SWTransaction | undefined];
+    'transaction.timeout': [SWTransaction | undefined];
     'transaction.submitStaking': [string];
     'transaction.transferNft': [SWTransaction | undefined];
     'mantaPay.initSync': [string | undefined];

package/services/history-service/index.js

@@ -166,14 +166,18 @@ export class HistoryService {
 
   // Insert history with check override origin 'app'
   async addHistoryItems(historyItems) {
-    // Prevent override record with original is 'app'
-    const appRecords = this.historySubject.value.filter(item => item.origin === 'app');
-    const excludeKeys = appRecords.map(item => {
-      return `${item.chain}-${item.extrinsicHash}`;
-    });
-    const updateRecords = historyItems.filter(item => {
-      const key = `${item.chain}-${item.extrinsicHash}`;
-      return item.origin === 'app' || !excludeKeys.includes(key);
+    const updateRecords = [];
+    const appItems = this.historySubject.value.filter(i => i.origin === 'app');
+    historyItems.forEach(item => {
+      const needUpdateItem = appItems.find(item_ => item_.extrinsicHash === item.extrinsicHash && item.chain === item_.chain && item.address === item_.address);
+      if (needUpdateItem) {
+        updateRecords.push({
+          ...needUpdateItem,
+          status: item.status
+        });
+        return;
+      }
+      updateRecords.push(item);
     });
     await this.dbService.upsertHistory(updateRecords);
     this.historySubject.next(await this.dbService.getHistories());

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

@@ -7,6 +7,10 @@ import { HexString } from '@polkadot/util/types';
 export default class TransactionService {
     private readonly state;
     private readonly transactionSubject;
+    private readonly eventService;
+    private readonly historyService;
+    private readonly notificationService;
+    private readonly chainService;
     private readonly watchTransactionSubscribes;
     private get transactions();
     constructor(state: KoniState);
@@ -31,6 +35,7 @@ export default class TransactionService {
     private handlePostProcessing;
     private onSuccess;
     private onFailed;
+    private onTimeOut;
     generateHashPayload(chain: string, transaction: TransactionConfig): HexString;
     private signAndSendEvmTransaction;
     private signAndSendSubstrateTransaction;

package/services/transaction-service/index.js

@@ -35,6 +35,10 @@ export default class TransactionService {
   }
   constructor(state) {
     this.state = state;
+    this.eventService = state.eventService;
+    this.historyService = state.historyService;
+    this.notificationService = state.notificationService;
+    this.chainService = state.chainService;
   }
   get allTransactions() {
     return Object.values(this.transactions);
@@ -290,6 +294,12 @@ export default class TransactionService {
         errors: [...data.errors, new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]
       });
     });
+    emitter.on('timeout', data => {
+      this.onTimeOut({
+        ...data,
+        errors: [...data.errors, new TransactionError(BasicTxErrorType.TIMEOUT)]
+      });
+    });
 
     // Todo: handle any event with transaction.eventsHandler
 
@@ -788,6 +798,44 @@ export default class TransactionService {
     }
     this.state.eventService.emit('transaction.failed', transaction);
   }
+  onTimeOut({
+    blockHash,
+    blockNumber,
+    errors,
+    extrinsicHash,
+    id
+  }) {
+    const transaction = this.getTransaction(id);
+    const nextStatus = ExtrinsicStatus.TIMEOUT;
+    if (transaction) {
+      this.updateTransaction(id, {
+        status: nextStatus,
+        errors,
+        extrinsicHash
+      });
+      this.historyService.updateHistoryByExtrinsicHash(transaction.extrinsicHash, {
+        extrinsicHash: extrinsicHash || transaction.extrinsicHash,
+        status: nextStatus,
+        blockNumber: blockNumber || 0,
+        blockHash: blockHash || ''
+      }).catch(console.error);
+      const info = isHex(transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash) ? transaction === null || transaction === void 0 ? void 0 : transaction.extrinsicHash : getBaseTransactionInfo(transaction, this.chainService.getChainInfoMap());
+      this.notificationService.notify({
+        type: NotificationType.ERROR,
+        title: t('Transaction timed out'),
+        message: t('Transaction {{info}} timed out', {
+          replace: {
+            info
+          }
+        }),
+        action: {
+          url: this.getTransactionLink(id)
+        },
+        notifyViaBrowser: true
+      });
+    }
+    this.eventService.emit('transaction.timeout', transaction);
+  }
   generateHashPayload(chain, transaction) {
     var _transaction$nonce;
     const chainInfo = this.state.chainService.getChainInfoByKey(chain);
@@ -1086,7 +1134,7 @@ export default class TransactionService {
       const transaction = this.getTransaction(eventData.id);
       if (transaction.status !== ExtrinsicStatus.SUCCESS && transaction.status !== ExtrinsicStatus.FAIL) {
         eventData.errors.push(new TransactionError(BasicTxErrorType.TIMEOUT, t('Transaction timeout')));
-        emitter.emit('error', eventData);
+        emitter.emit('timeout', eventData);
         clearTimeout(timeout);
       }
     }, TRANSACTION_TIMEOUT);

package/services/transaction-service/types.d.ts

@@ -51,5 +51,6 @@ export interface TransactionEventMap {
     extrinsicHash: (response: TransactionEventResponse) => void;
     error: (response: TransactionEventResponse) => void;
     success: (response: TransactionEventResponse) => void;
+    timeout: (response: TransactionEventResponse) => void;
 }
 export {};