@subwallet/extension-base 1.0.7-0 → 1.0.7-2

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

@@ -77,8 +77,7 @@ class KoniState {
   stakingRewardSubject = new _rxjs.Subject();
   stakingRewardState = {
     ready: false,
-    slowInterval: [],
-    fastInterval: []
+    data: {}
   };
   lazyMap = {};
   ready = false;
@@ -203,18 +202,24 @@ class KoniState {
   async init() {
     await this.chainService.init();
     await this.migrationService.run();
-    this.startSubscription();
     this.eventService.emit('chain.ready', true);
     this.onReady();
     this.onAccountAdd();
     this.onAccountRemove();
+    await this.startSubscription();
   }
-  startSubscription() {
+  async startSubscription() {
+    await this.eventService.waitKeyringReady;
     this.dbService.subscribeChainStakingMetadata([], data => {
       this.chainStakingMetadataSubject.next(data);
     });
-    this.dbService.subscribeNominatorMetadata(data => {
-      this.stakingNominatorMetadataSubject.next(data);
+    let unsub;
+    this.keyringService.accountSubject.subscribe(accounts => {
+      // TODO: improve this
+      unsub && unsub.unsubscribe();
+      unsub = this.dbService.subscribeNominatorMetadata(Object.keys(accounts), data => {
+        this.stakingNominatorMetadataSubject.next(data);
+      });
     });
   }
   onReady() {
@@ -309,14 +314,6 @@ class KoniState {
   async getPooledStakingRecordsByAddress(addresses) {
     return this.dbService.getPooledStakings(addresses, this.activeChainSlugs);
   }
-
-  // TODO: delete later
-  // public async getStoredStaking (address: string) {
-  //   const items = await this.dbService.stores.staking.getDataByAddressAsObject(address);
-  //
-  //   return items || {};
-  // }
-
   subscribeStaking() {
     return this.stakingSubject;
   }
@@ -332,8 +329,8 @@ class KoniState {
   setStakingItem(networkKey, item) {
     this.dbService.updateStaking(networkKey, item.address, item).catch(e => this.logger.warn(e));
   }
-  updateChainStakingMetadata(item) {
-    this.dbService.updateChainStakingMetadata(item).catch(e => this.logger.warn(e));
+  updateChainStakingMetadata(item, changes) {
+    this.dbService.updateChainStakingMetadata(item, changes).catch(e => this.logger.warn(e));
   }
   updateStakingNominatorMetadata(item) {
     this.dbService.updateNominatorMetadata(item).catch(e => this.logger.warn(e));
@@ -386,12 +383,13 @@ class KoniState {
     return this.nftSubject;
   }
   resetStakingReward() {
-    this.stakingRewardState.slowInterval = [];
+    this.stakingRewardState.data = {};
     this.stakingRewardSubject.next(this.stakingRewardState);
   }
-  updateStakingReward(stakingRewardData, type, callback) {
+  updateStakingReward(stakingRewardData, callback) {
     this.stakingRewardState.ready = true;
-    this.stakingRewardState[type] = stakingRewardData;
+    const key = `${stakingRewardData.chain}___${stakingRewardData.address}___${stakingRewardData.type}`;
+    this.stakingRewardState.data[key] = stakingRewardData;
     if (callback) {
       callback(this.stakingRewardState);
     }

package/cjs/koni/background/subscription.js

@@ -26,7 +26,8 @@ class KoniSubscription {
   subscriptionMap = {
     crowdloan: undefined,
     balance: undefined,
-    stakingOnChain: undefined
+    stakingOnChain: undefined,
+    essentialChainStakingMetadata: undefined
   };
   constructor(state, dbService) {
     this.dbService = dbService;
@@ -105,11 +106,38 @@ class KoniSubscription {
       return;
     }
     this.updateSubscription('stakingOnChain', this.initStakingOnChainSubscription(addresses, substrateApiMap, onlyRunOnFirstTime));
+    this.updateSubscription('essentialChainStakingMetadata', this.initEssentialChainStakingMetadataSubscription(substrateApiMap, onlyRunOnFirstTime)); // TODO: might not need to re-subscribe on changing account
   }
+
   initStakingOnChainSubscription(addresses, substrateApiMap, onlyRunOnFirstTime) {
-    const unsub = (0, _staking.stakingOnChainApi)(addresses, substrateApiMap, (networkKey, rs) => {
+    const stakingCallback = (networkKey, rs) => {
       this.state.setStakingItem(networkKey, rs);
-    }, this.state.getActiveChainInfoMap());
+    };
+    const nominatorStateCallback = nominatorMetadata => {
+      this.state.updateStakingNominatorMetadata(nominatorMetadata);
+    };
+    const unsub = (0, _staking.stakingOnChainApi)(addresses, substrateApiMap, this.state.getActiveChainInfoMap(), stakingCallback, nominatorStateCallback);
+    if (onlyRunOnFirstTime) {
+      unsub && unsub();
+      return;
+    }
+    return () => {
+      unsub && unsub();
+    };
+  }
+  initEssentialChainStakingMetadataSubscription(substrateApiMap, onlyRunOnFirstTime) {
+    const unsub = (0, _bonding.subscribeEssentialChainStakingMetadata)(substrateApiMap, this.state.getActiveChainInfoMap(), (networkKey, rs) => {
+      this.state.updateChainStakingMetadata(rs, {
+        era: rs.era,
+        minStake: rs.minStake,
+        maxValidatorPerNominator: rs.maxValidatorPerNominator,
+        // temporary fix for Astar, there's no limit for now
+        maxWithdrawalRequestPerValidator: rs.maxWithdrawalRequestPerValidator,
+        // by default
+        allowCancelUnstaking: rs.allowCancelUnstaking,
+        unstakingPeriod: rs.unstakingPeriod
+      });
+    });
     if (onlyRunOnFirstTime) {
       unsub && unsub();
       return;
@@ -183,8 +211,9 @@ class KoniSubscription {
         targetNetworkMap[key] = network;
       }
     });
-    const result = await (0, _staking.getNominationStakingRewardData)(addresses, targetNetworkMap);
-    this.state.updateStakingReward(result, 'slowInterval');
+    await (0, _staking.getNominationStakingRewardData)(addresses, targetNetworkMap, rewardItem => {
+      this.state.updateStakingReward(rewardItem);
+    });
   }
   async subscribeStakingRewardFastInterval(address) {
     const addresses = this.state.getDecodedAddresses(address);
@@ -211,9 +240,10 @@ class KoniSubscription {
     Object.keys(targetChainMap).forEach(key => {
       activeNetworks.push(key);
     });
-    const [poolingStakingRewards, amplitudeUnclaimedStakingRewards] = await Promise.all([(0, _staking.getPoolingStakingRewardData)(pooledAddresses, targetChainMap, this.state.getSubstrateApiMap()), (0, _paraChain.getAmplitudeUnclaimedStakingReward)(this.state.getSubstrateApiMap(), addresses, chainInfoMap, activeNetworks)]);
-    const result = [...poolingStakingRewards, ...amplitudeUnclaimedStakingRewards];
-    this.state.updateStakingReward(result, 'fastInterval');
+    const updateState = result => {
+      this.state.updateStakingReward(result);
+    };
+    await Promise.all([(0, _staking.getPoolingStakingRewardData)(pooledAddresses, targetChainMap, this.state.getSubstrateApiMap(), updateState), (0, _paraChain.getAmplitudeUnclaimedStakingReward)(this.state.getSubstrateApiMap(), addresses, chainInfoMap, activeNetworks, updateState)]);
   }
   async fetchingStakingFromApi() {
     try {
@@ -237,16 +267,31 @@ class KoniSubscription {
     if (Object.values(filteredChainInfoMap).length === 0) {
       return;
     }
+    const timeout = new Promise(resolve => {
+      const id = setTimeout(() => {
+        clearTimeout(id);
+        resolve(null);
+      }, 3000);
+    });
 
     // Fetch data from helper API
-    const dataFromApi = await this.fetchingStakingFromApi();
+    const _dataFromApi = await Promise.race([this.fetchingStakingFromApi(), timeout]);
+    const dataFromApi = _dataFromApi;
     await Promise.all(Object.values(filteredChainInfoMap).map(async chainInfo => {
       // Use fetch API data if available
-      if (dataFromApi[chainInfo.slug]) {
-        this.state.updateChainStakingMetadata(dataFromApi[chainInfo.slug]);
+      if (dataFromApi && dataFromApi[chainInfo.slug]) {
+        this.state.updateChainStakingMetadata(dataFromApi[chainInfo.slug], {
+          expectedReturn: dataFromApi[chainInfo.slug].expectedReturn,
+          inflation: dataFromApi[chainInfo.slug].inflation,
+          nominatorCount: dataFromApi[chainInfo.slug].nominatorCount
+        });
       } else {
         const chainStakingMetadata = await (0, _bonding.getChainStakingMetadata)(chainInfo, substrateApiMap[chainInfo.slug]);
-        this.state.updateChainStakingMetadata(chainStakingMetadata);
+        this.state.updateChainStakingMetadata(chainStakingMetadata, {
+          expectedReturn: chainStakingMetadata.expectedReturn,
+          inflation: chainStakingMetadata.inflation,
+          nominatorCount: chainStakingMetadata.nominatorCount
+        });
       }
     }));
   }

package/cjs/packageInfo.js

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

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

@@ -66,7 +66,9 @@ const _STAKING_CHAIN_GROUP = {
   kilt: ['kilt', 'kilt_peregrine'],
   nominationPool: ['polkadot', 'kusama', 'westend', 'alephTest', 'aleph'],
   bifrost: ['bifrost', 'bifrost_testnet'],
-  aleph: ['aleph', 'alephTest'] // A0 has distinct tokenomics
+  aleph: ['aleph', 'alephTest'],
+  // A0 has distinct tokenomics
+  ternoa: ['ternoa', 'ternoa_alphanet']
 };
 exports._STAKING_CHAIN_GROUP = _STAKING_CHAIN_GROUP;
 const _STAKING_ERA_LENGTH_MAP = {

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

@@ -121,7 +121,12 @@ function _isPureSubstrateChain(chainInfo) {
 }
 function _getOriginChainOfAsset(assetSlug) {
   if (assetSlug.startsWith(_types2._CUSTOM_PREFIX)) {
-    return assetSlug.split('-')[1];
+    const arr = assetSlug.split('-').slice(1);
+    if (arr[0] === 'custom') {
+      const end = arr.findIndex(str => Object.values(_types._AssetType).includes(str));
+      return arr.slice(0, end).join('-');
+    }
+    return arr[0];
   }
   return assetSlug.split('-')[0];
 }

package/cjs/services/storage-service/DatabaseService.js

@@ -106,8 +106,8 @@ class DatabaseService {
       next: data => callback && callback(data)
     });
   }
-  subscribeNominatorMetadata(callback) {
-    this.stores.nominatorMetadata.subscribeAll().subscribe({
+  subscribeNominatorMetadata(addresses, callback) {
+    return this.stores.nominatorMetadata.subscribeByAddresses(addresses).subscribe({
       next: data => callback && callback(data)
     });
   }
@@ -198,7 +198,11 @@ class DatabaseService {
   }
 
   // Staking
-  async updateChainStakingMetadata(item) {
+  async updateChainStakingMetadata(item, changes) {
+    const existingRecord = await this.stores.chainStakingMetadata.getByChainAndType(item.chain, item.type);
+    if (existingRecord && changes) {
+      return this.stores.chainStakingMetadata.updateByChainAndType(item.chain, item.type, changes);
+    }
     return this.stores.chainStakingMetadata.upsert(item);
   }
   async getChainStakingMetadata() {

package/cjs/services/storage-service/db-stores/ChainStakingMetadata.js

@@ -34,5 +34,10 @@ class ChainStakingMetadataStore extends _BaseStoreWithChain.default {
   async removeByChains(chains) {
     return this.table.where('chain').anyOfIgnoreCase(chains).delete();
   }
+  updateByChainAndType(chain) {
+    let type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _KoniTypes.StakingType.NOMINATED;
+    let changes = arguments.length > 2 ? arguments[2] : undefined;
+    return this.table.update([chain, type], changes);
+  }
 }
 exports.default = ChainStakingMetadataStore;

package/cjs/services/storage-service/db-stores/NominatorMetadata.js

@@ -14,14 +14,14 @@ class NominatorMetadataStore extends _BaseStoreWithAddressAndChain.default {
   async getAll() {
     return this.table.toArray();
   }
-  subscribeByAddress(address) {
-    return (0, _dexie.liveQuery)(() => this.getByAddress(address));
+  subscribeByAddresses(addresses) {
+    return (0, _dexie.liveQuery)(() => this.getByAddress(addresses));
   }
   subscribeAll() {
     return (0, _dexie.liveQuery)(() => this.getAll());
   }
-  getByAddress(address) {
-    return this.table.where('address').anyOfIgnoreCase(address).toArray();
+  getByAddress(addresses) {
+    return this.table.where('address').anyOfIgnoreCase(addresses).toArray();
   }
   async removeByAddress(address) {
     return this.table.where('address').anyOfIgnoreCase(address).delete();

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

@@ -644,7 +644,12 @@ class TransactionService {
     if (!payload.parseData) {
       const isToContract = await (0, _parseTransaction.isContractAddress)(payload.to || '', evmApi);
       payload.isToContract = isToContract;
-      payload.parseData = isToContract ? payload.data ? (await (0, _parseTransaction.parseContractInput)(payload.data || '', payload.to || '', chainInfo)).result : '' : payload.data || '';
+      try {
+        payload.parseData = isToContract ? payload.data ? (await (0, _parseTransaction.parseContractInput)(payload.data || '', payload.to || '', chainInfo)).result : '' : payload.data || '';
+      } catch (e) {
+        console.warn('Unable to parse contract input data');
+        payload.parseData = payload.data;
+      }
     }
     if ('data' in payload && payload.data === undefined) {
       delete payload.data;

package/constants/index.d.ts

@@ -6,7 +6,7 @@ export declare const ASTAR_REFRESH_BALANCE_INTERVAL = 60000;
 export declare const SUB_TOKEN_REFRESH_BALANCE_INTERVAL = 60000;
 export declare const CRON_REFRESH_NFT_INTERVAL = 7200000;
 export declare const CRON_REFRESH_STAKING_REWARD_INTERVAL = 900000;
-export declare const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 45000;
+export declare const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 300000;
 export declare const CRON_REFRESH_HISTORY_INTERVAL = 900000;
 export declare const CRON_GET_API_MAP_STATUS = 10000;
 export declare const CRON_REFRESH_CHAIN_STAKING_METADATA = 900000;

package/constants/index.js

@@ -9,7 +9,7 @@ export const ASTAR_REFRESH_BALANCE_INTERVAL = 60000;
 export const SUB_TOKEN_REFRESH_BALANCE_INTERVAL = 60000;
 export const CRON_REFRESH_NFT_INTERVAL = 7200000;
 export const CRON_REFRESH_STAKING_REWARD_INTERVAL = 900000;
-export const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 45000;
+export const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 300000;
 export const CRON_REFRESH_HISTORY_INTERVAL = 900000;
 export const CRON_GET_API_MAP_STATUS = 10000;
 export const CRON_REFRESH_CHAIN_STAKING_METADATA = 900000;

package/koni/api/staking/bonding/amplitude.d.ts

@@ -1,7 +1,11 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { ChainStakingMetadata, NominatorMetadata, ValidatorInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { ParachainStakingStakeOption } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { Codec } from '@polkadot/types/types';
+export declare function subscribeAmplitudeStakingMetadata(chain: string, substrateApi: _SubstrateApi, callback: (chain: string, rs: ChainStakingMetadata) => void): Promise<Codec>;
 export declare function getAmplitudeStakingMetadata(chain: string, substrateApi: _SubstrateApi): Promise<ChainStakingMetadata>;
+export declare function subscribeAmplitudeNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi, delegatorState: ParachainStakingStakeOption, unstakingInfo: Record<string, number>): Promise<NominatorMetadata>;
 export declare function getAmplitudeNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi): Promise<NominatorMetadata | undefined>;
 export declare function getAmplitudeCollatorsInfo(chain: string, substrateApi: _SubstrateApi): Promise<ValidatorInfo[]>;
 export declare function getAmplitudeBondingExtrinsic(substrateApi: _SubstrateApi, amount: string, selectedValidatorInfo: ValidatorInfo, nominatorMetadata?: NominatorMetadata): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;

package/koni/api/staking/bonding/amplitude.js

@@ -7,6 +7,30 @@ import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chai
 import { parseRawNumber, reformatAddress } from '@subwallet/extension-base/utils';
 import { BN, BN_ZERO } from '@polkadot/util';
 import { isEthereumAddress } from '@polkadot/util-crypto';
+export function subscribeAmplitudeStakingMetadata(chain, substrateApi, callback) {
+  return substrateApi.api.query.parachainStaking.round(_round => {
+    const roundObj = _round.toHuman();
+    const round = parseRawNumber(roundObj.current);
+    const maxDelegations = substrateApi.api.consts.parachainStaking.maxDelegationsPerRound.toString();
+    const minDelegatorStake = substrateApi.api.consts.parachainStaking.minDelegatorStake.toString();
+    const unstakingDelay = substrateApi.api.consts.parachainStaking.stakeDuration.toString();
+    const _blockPerRound = substrateApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
+    const blockPerRound = parseFloat(_blockPerRound);
+    const blockDuration = (_STAKING_ERA_LENGTH_MAP[chain] || _STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
+    const unstakingPeriod = blockDuration * parseInt(unstakingDelay);
+    callback(chain, {
+      chain,
+      type: StakingType.NOMINATED,
+      era: round,
+      minStake: minDelegatorStake,
+      maxValidatorPerNominator: parseInt(maxDelegations),
+      maxWithdrawalRequestPerValidator: 1,
+      // by default
+      allowCancelUnstaking: true,
+      unstakingPeriod
+    });
+  });
+}
 export async function getAmplitudeStakingMetadata(chain, substrateApi) {
   const chainApi = await substrateApi.isReady;
   const _round = (await chainApi.api.query.parachainStaking.round()).toHuman();
@@ -30,6 +54,63 @@ export async function getAmplitudeStakingMetadata(chain, substrateApi) {
     unstakingPeriod
   };
 }
+export async function subscribeAmplitudeNominatorMetadata(chainInfo, address, substrateApi, delegatorState, unstakingInfo) {
+  const nominationList = [];
+  const unstakingList = [];
+  const minDelegatorStake = substrateApi.api.consts.parachainStaking.minDelegatorStake.toString();
+  let activeStake = '0';
+  if (delegatorState) {
+    // delegatorState can be null while unstaking all
+    const identityInfo = substrateApi.api.query.identity ? (await substrateApi.api.query.identity.identityOf(delegatorState.owner)).toPrimitive() : undefined;
+    const identity = identityInfo ? parseIdentity(identityInfo) : undefined;
+    activeStake = delegatorState.amount.toString();
+    const bnActiveStake = new BN(activeStake);
+    let delegationStatus = StakingStatus.NOT_EARNING;
+    if (bnActiveStake.gt(BN_ZERO) && bnActiveStake.gte(new BN(minDelegatorStake))) {
+      delegationStatus = StakingStatus.EARNING_REWARD;
+    }
+    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
+
+    const isClaimable = parseInt(nearestUnstakingBlock) - currentBlockNumber <= 0;
+    const remainingBlock = parseInt(nearestUnstakingBlock) - (currentBlockNumber + 1);
+    const waitingTime = remainingBlock * blockDuration;
+    unstakingList.push({
+      chain: chainInfo.slug,
+      status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
+      claimable: nearestUnstakingAmount.toString(),
+      waitingTime: waitingTime > 0 ? waitingTime : 0,
+      validatorAddress: (delegatorState === null || delegatorState === void 0 ? void 0 : delegatorState.owner) || undefined
+    });
+  }
+  const stakingStatus = getStakingStatusByNominations(new BN(activeStake), nominationList);
+  return {
+    chain: chainInfo.slug,
+    type: StakingType.NOMINATED,
+    status: stakingStatus,
+    address: address,
+    activeStake: activeStake,
+    nominations: nominationList,
+    unstakings: unstakingList
+  };
+}
 export async function getAmplitudeNominatorMetadata(chainInfo, address, substrateApi) {
   if (isEthereumAddress(address)) {
     return;

package/koni/api/staking/bonding/astar.d.ts

@@ -1,7 +1,11 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { ChainStakingMetadata, NominatorMetadata, UnstakingInfo, ValidatorInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { PalletDappsStakingAccountLedger } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
 import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { Codec } from '@polkadot/types/types';
+export declare function subscribeAstarStakingMetadata(chain: string, substrateApi: _SubstrateApi, callback: (chain: string, rs: ChainStakingMetadata) => void): Promise<Codec>;
 export declare function getAstarStakingMetadata(chain: string, substrateApi: _SubstrateApi): Promise<ChainStakingMetadata>;
+export declare function subscribeAstarNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi, ledger: PalletDappsStakingAccountLedger): Promise<NominatorMetadata>;
 export declare function getAstarNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi): Promise<NominatorMetadata | undefined>;
 export declare function getAstarDappsInfo(networkKey: string, substrateApi: _SubstrateApi): Promise<ValidatorInfo[]>;
 export declare function getAstarBondingExtrinsic(substrateApi: _SubstrateApi, amount: string, dappInfo: ValidatorInfo): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;

package/koni/api/staking/bonding/astar.js

@@ -8,6 +8,26 @@ import { isUrl, parseRawNumber } from '@subwallet/extension-base/utils';
 import fetch from 'cross-fetch';
 import { BN, BN_ZERO } from '@polkadot/util';
 import { isEthereumAddress } from '@polkadot/util-crypto';
+export function subscribeAstarStakingMetadata(chain, substrateApi, callback) {
+  return substrateApi.api.query.dappsStaking.currentEra(_currentEra => {
+    const era = _currentEra.toString();
+    const minDelegatorStake = substrateApi.api.consts.dappsStaking.minimumStakingAmount.toString();
+    const unstakingDelay = substrateApi.api.consts.dappsStaking.unbondingPeriod.toString();
+    const unstakingPeriod = parseInt(unstakingDelay) * _STAKING_ERA_LENGTH_MAP[chain];
+    callback(chain, {
+      chain,
+      type: StakingType.NOMINATED,
+      era: parseInt(era),
+      minStake: minDelegatorStake,
+      maxValidatorPerNominator: 100,
+      // temporary fix for Astar, there's no limit for now
+      maxWithdrawalRequestPerValidator: 1,
+      // by default
+      allowCancelUnstaking: true,
+      unstakingPeriod
+    });
+  });
+}
 export async function getAstarStakingMetadata(chain, substrateApi) {
   const aprPromise = new Promise(function (resolve) {
     fetch(`https://api.astar.network/api/v1/${chain}/dapps-staking/apr`, {
@@ -43,6 +63,87 @@ export async function getAstarStakingMetadata(chain, substrateApi) {
     unstakingPeriod
   };
 }
+export async function subscribeAstarNominatorMetadata(chainInfo, address, substrateApi, ledger) {
+  const nominationList = [];
+  const unstakingList = [];
+  const allDappsReq = new Promise(function (resolve) {
+    fetch(`https://api.astar.network/api/v1/${chainInfo.slug}/dapps-staking/dapps`, {
+      method: 'GET'
+    }).then(resp => {
+      resolve(resp.json());
+    }).catch(console.error);
+  });
+  const [_allDapps, _era, _stakerInfo] = await Promise.all([allDappsReq, substrateApi.api.query.dappsStaking.currentEra(), substrateApi.api.query.dappsStaking.generalStakerInfo.entries(address)]);
+  const currentEra = _era.toString();
+  const minDelegatorStake = substrateApi.api.consts.dappsStaking.minimumStakingAmount.toString();
+  const allDapps = _allDapps;
+  let bnTotalActiveStake = BN_ZERO;
+  if (_stakerInfo.length > 0) {
+    const dAppInfoMap = {};
+    allDapps.forEach(dappInfo => {
+      dAppInfoMap[dappInfo.address.toLowerCase()] = dappInfo;
+    });
+    for (const item of _stakerInfo) {
+      const data = item[0].toHuman();
+      const stakedDapp = data[1];
+      const stakeData = item[1].toPrimitive();
+      const stakeList = stakeData.stakes;
+      const dappAddress = stakedDapp.Evm ? stakedDapp.Evm.toLowerCase() : stakedDapp.Wasm;
+      const currentStake = stakeList.slice(-1)[0].staked.toString() || '0';
+      const bnCurrentStake = new BN(currentStake);
+      if (bnCurrentStake.gt(BN_ZERO)) {
+        const dappStakingStatus = bnCurrentStake.gt(BN_ZERO) && bnCurrentStake.gte(new BN(minDelegatorStake)) ? StakingStatus.EARNING_REWARD : StakingStatus.NOT_EARNING;
+        bnTotalActiveStake = bnTotalActiveStake.add(bnCurrentStake);
+        const dappInfo = dAppInfoMap[dappAddress];
+        nominationList.push({
+          status: dappStakingStatus,
+          chain: chainInfo.slug,
+          validatorAddress: dappAddress.toLowerCase(),
+          activeStake: currentStake,
+          validatorMinStake: '0',
+          validatorIdentity: dappInfo === null || dappInfo === void 0 ? void 0 : dappInfo.name,
+          hasUnstaking: false // cannot get unstaking info by dapp
+        });
+      }
+    }
+  }
+
+  const unlockingChunks = ledger.unbondingInfo.unlockingChunks;
+  if (unlockingChunks.length > 0) {
+    for (const unlockingChunk of unlockingChunks) {
+      const isClaimable = unlockingChunk.unlockEra - parseInt(currentEra) <= 0;
+      const remainingEra = unlockingChunk.unlockEra - (parseInt(currentEra) + 1);
+      const waitingTime = remainingEra * _STAKING_ERA_LENGTH_MAP[chainInfo.slug];
+      unstakingList.push({
+        chain: chainInfo.slug,
+        status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
+        claimable: unlockingChunk.amount.toString(),
+        waitingTime: waitingTime > 0 ? waitingTime : 0
+      });
+    }
+  }
+  if (nominationList.length === 0 && unstakingList.length === 0) {
+    return {
+      chain: chainInfo.slug,
+      type: StakingType.NOMINATED,
+      address,
+      status: StakingStatus.NOT_STAKING,
+      activeStake: '0',
+      nominations: [],
+      unstakings: []
+    };
+  }
+  const stakingStatus = getStakingStatusByNominations(bnTotalActiveStake, nominationList);
+  return {
+    chain: chainInfo.slug,
+    type: StakingType.NOMINATED,
+    address: address,
+    activeStake: bnTotalActiveStake.toString(),
+    nominations: nominationList,
+    unstakings: unstakingList,
+    status: stakingStatus
+  };
+}
 export async function getAstarNominatorMetadata(chainInfo, address, substrateApi) {
   if (isEthereumAddress(address)) {
     return;
@@ -67,14 +168,15 @@ export async function getAstarNominatorMetadata(chainInfo, address, substrateApi
     const dAppInfoMap = {};
     const allDapps = await allDappsReq;
     allDapps.forEach(dappInfo => {
-      dAppInfoMap[dappInfo.address.toLowerCase()] = dappInfo;
+      const address = isEthereumAddress(dappInfo.address) ? dappInfo.address.toLowerCase() : dappInfo.address;
+      dAppInfoMap[address] = dappInfo;
     });
     for (const item of _stakerInfo) {
       const data = item[0].toHuman();
       const stakedDapp = data[1];
       const stakeData = item[1].toPrimitive();
       const stakeList = stakeData.stakes;
-      const dappAddress = stakedDapp.Evm.toLowerCase();
+      const dappAddress = isEthereumAddress(stakedDapp.Evm) ? stakedDapp.Evm.toLowerCase() : stakedDapp.Evm;
       const currentStake = stakeList.slice(-1)[0].staked.toString() || '0';
       const bnCurrentStake = new BN(currentStake);
       if (bnCurrentStake.gt(BN_ZERO)) {
@@ -84,7 +186,7 @@ export async function getAstarNominatorMetadata(chainInfo, address, substrateApi
         nominationList.push({
           status: dappStakingStatus,
           chain,
-          validatorAddress: dappAddress.toLowerCase(),
+          validatorAddress: dappAddress,
           activeStake: currentStake,
           validatorMinStake: '0',
           validatorIdentity: dappInfo === null || dappInfo === void 0 ? void 0 : dappInfo.name,
@@ -167,7 +269,7 @@ export async function getAstarDappsInfo(networkKey, substrateApi) {
     allDappsInfo.push({
       commission: 0,
       expectedReturn: 0,
-      address: dappAddress.toLowerCase(),
+      address: isEthereumAddress(dappAddress) ? dappAddress.toLowerCase() : dappAddress,
       totalStake: totalStake,
       ownStake: '0',
       otherStake: totalStake.toString(),
@@ -217,7 +319,7 @@ export async function getAstarClaimRewardExtrinsic(substrateApi, address) {
     const stakedDapp = data[1];
     const stakeData = item[1].toHuman();
     const stakes = stakeData.stakes;
-    const dappAddress = stakedDapp.Evm.toLowerCase();
+    const dappAddress = isEthereumAddress(stakedDapp.Evm) ? stakedDapp.Evm.toLowerCase() : stakedDapp.Evm;
     let numberOfUnclaimedEra = 0;
     const maxTx = 50;
     for (let i = 0; i < stakes.length; i++) {

package/koni/api/staking/bonding/index.d.ts

@@ -13,3 +13,4 @@ export declare function getUnbondingExtrinsic(nominatorMetadata: NominatorMetada
 export declare function getWithdrawalExtrinsic(substrateApi: _SubstrateApi, chain: string, nominatorMetadata: NominatorMetadata, validatorAddress?: string): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
 export declare function getClaimRewardExtrinsic(substrateApi: _SubstrateApi, chain: string, address: string, stakingType: StakingType, bondReward?: boolean): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
 export declare function getCancelWithdrawalExtrinsic(substrateApi: _SubstrateApi, chain: string, selectedUnstaking: UnstakingInfo): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function subscribeEssentialChainStakingMetadata(substrateApiMap: Record<string, _SubstrateApi>, chainInfoMap: Record<string, _ChainInfo>, callback: (chain: string, rs: ChainStakingMetadata) => void): () => void;