@subwallet/extension-base 1.0.6-2 → 1.0.7-1

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;
@@ -167,7 +268,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(),

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;

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

@@ -2,10 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { StakingType } from '@subwallet/extension-base/background/KoniTypes';
-import { getAmplitudeBondingExtrinsic, getAmplitudeClaimRewardExtrinsic, getAmplitudeCollatorsInfo, getAmplitudeNominatorMetadata, getAmplitudeStakingMetadata, getAmplitudeUnbondingExtrinsic, getAmplitudeWithdrawalExtrinsic } from '@subwallet/extension-base/koni/api/staking/bonding/amplitude';
-import { getAstarBondingExtrinsic, getAstarClaimRewardExtrinsic, getAstarDappsInfo, getAstarNominatorMetadata, getAstarStakingMetadata, getAstarUnbondingExtrinsic, getAstarWithdrawalExtrinsic } from '@subwallet/extension-base/koni/api/staking/bonding/astar';
-import { getParaBondingExtrinsic, getParaCancelWithdrawalExtrinsic, getParachainCollatorsInfo, getParaChainNominatorMetadata, getParaChainStakingMetadata, getParaUnbondingExtrinsic, getParaWithdrawalExtrinsic, validateParaChainBondingCondition, validateParaChainUnbondingCondition } from '@subwallet/extension-base/koni/api/staking/bonding/paraChain';
-import { getPoolingClaimRewardExtrinsic, getPoolingWithdrawalExtrinsic, getRelayBondingExtrinsic, getRelayCancelWithdrawalExtrinsic, getRelayChainNominatorMetadata, getRelayChainStakingMetadata, getRelayPoolsInfo, getRelayUnbondingExtrinsic, getRelayValidatorsInfo, getRelayWithdrawalExtrinsic, validateRelayBondingCondition, validateRelayUnbondingCondition } from '@subwallet/extension-base/koni/api/staking/bonding/relayChain';
+import { getAmplitudeBondingExtrinsic, getAmplitudeClaimRewardExtrinsic, getAmplitudeCollatorsInfo, getAmplitudeNominatorMetadata, getAmplitudeStakingMetadata, getAmplitudeUnbondingExtrinsic, getAmplitudeWithdrawalExtrinsic, subscribeAmplitudeStakingMetadata } from '@subwallet/extension-base/koni/api/staking/bonding/amplitude';
+import { getAstarBondingExtrinsic, getAstarClaimRewardExtrinsic, getAstarDappsInfo, getAstarNominatorMetadata, getAstarStakingMetadata, getAstarUnbondingExtrinsic, getAstarWithdrawalExtrinsic, subscribeAstarStakingMetadata } from '@subwallet/extension-base/koni/api/staking/bonding/astar';
+import { getParaBondingExtrinsic, getParaCancelWithdrawalExtrinsic, getParachainCollatorsInfo, getParaChainNominatorMetadata, getParaChainStakingMetadata, getParaUnbondingExtrinsic, getParaWithdrawalExtrinsic, subscribeParaChainStakingMetadata, validateParaChainBondingCondition, validateParaChainUnbondingCondition } from '@subwallet/extension-base/koni/api/staking/bonding/paraChain';
+import { getPoolingClaimRewardExtrinsic, getPoolingWithdrawalExtrinsic, getRelayBondingExtrinsic, getRelayCancelWithdrawalExtrinsic, getRelayChainNominatorMetadata, getRelayChainStakingMetadata, getRelayPoolsInfo, getRelayUnbondingExtrinsic, getRelayValidatorsInfo, getRelayWithdrawalExtrinsic, subscribeRelayChainStakingMetadata, validateRelayBondingCondition, validateRelayUnbondingCondition } from '@subwallet/extension-base/koni/api/staking/bonding/relayChain';
 import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
 // all addresses must be converted to its chain format
 
@@ -100,4 +100,38 @@ export async function getCancelWithdrawalExtrinsic(substrateApi, chain, selected
     return getParaCancelWithdrawalExtrinsic(substrateApi, selectedUnstaking);
   }
   return getRelayCancelWithdrawalExtrinsic(substrateApi, selectedUnstaking);
+}
+export function subscribeEssentialChainStakingMetadata(substrateApiMap, chainInfoMap, callback) {
+  const unsubList = [];
+
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  Object.values(chainInfoMap).forEach(async chainInfo => {
+    const substrateApi = await substrateApiMap[chainInfo.slug].isReady;
+    if (_STAKING_CHAIN_GROUP.astar.includes(chainInfo.slug)) {
+      const unsub = await subscribeAstarStakingMetadata(chainInfo.slug, substrateApi, callback);
+
+      // @ts-ignore
+      unsubList.push(unsub);
+    } else if (_STAKING_CHAIN_GROUP.para.includes(chainInfo.slug)) {
+      const unsub = await subscribeParaChainStakingMetadata(chainInfo.slug, substrateApi, callback);
+
+      // @ts-ignore
+      unsubList.push(unsub);
+    } else if (_STAKING_CHAIN_GROUP.amplitude.includes(chainInfo.slug)) {
+      const unsub = await subscribeAmplitudeStakingMetadata(chainInfo.slug, substrateApi, callback);
+
+      // @ts-ignore
+      unsubList.push(unsub);
+    } else if (_STAKING_CHAIN_GROUP.relay.includes(chainInfo.slug)) {
+      const unsub = await subscribeRelayChainStakingMetadata(chainInfo, substrateApi, callback);
+
+      // @ts-ignore
+      unsubList.push(unsub);
+    }
+  });
+  return () => {
+    unsubList.forEach(unsub => {
+      unsub && unsub();
+    });
+  };
 }

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

@@ -1,10 +1,14 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainStakingMetadata, NominatorMetadata, UnstakingInfo, ValidatorInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { PalletParachainStakingDelegator } 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 validateParaChainUnbondingCondition(amount: string, nominatorMetadata: NominatorMetadata, chainStakingMetadata: ChainStakingMetadata, selectedCollator: string): TransactionError[];
 export declare function validateParaChainBondingCondition(chainInfo: _ChainInfo, amount: string, selectedCollators: ValidatorInfo[], address: string, chainStakingMetadata: ChainStakingMetadata, nominatorMetadata?: NominatorMetadata): TransactionError[];
+export declare function subscribeParaChainStakingMetadata(chain: string, substrateApi: _SubstrateApi, callback: (chain: string, rs: ChainStakingMetadata) => void): Promise<Codec>;
 export declare function getParaChainStakingMetadata(chain: string, substrateApi: _SubstrateApi): Promise<ChainStakingMetadata>;
+export declare function subscribeParaChainNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi, delegatorState: PalletParachainStakingDelegator): Promise<NominatorMetadata>;
 export declare function getParaChainNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi): Promise<NominatorMetadata | undefined>;
 export declare function getParachainCollatorsInfo(chain: string, substrateApi: _SubstrateApi): Promise<ValidatorInfo[]>;
 export declare function getParaBondingExtrinsic(chainInfo: _ChainInfo, substrateApi: _SubstrateApi, amount: string, selectedCollatorInfo: ValidatorInfo, nominatorMetadata?: NominatorMetadata): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;

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

@@ -81,6 +81,26 @@ export function validateParaChainBondingCondition(chainInfo, amount, selectedCol
   }
   return errors;
 }
+export function subscribeParaChainStakingMetadata(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.maxDelegationsPerDelegator.toString();
+    const unstakingDelay = substrateApi.api.consts.parachainStaking.delegationBondLessDelay.toString();
+    const unstakingPeriod = parseInt(unstakingDelay) * (_STAKING_ERA_LENGTH_MAP[chain] || _STAKING_ERA_LENGTH_MAP.default);
+    callback(chain, {
+      chain,
+      type: StakingType.NOMINATED,
+      era: round,
+      minStake: '0',
+      maxValidatorPerNominator: parseInt(maxDelegations),
+      maxWithdrawalRequestPerValidator: 1,
+      // by default
+      allowCancelUnstaking: true,
+      unstakingPeriod
+    });
+  });
+}
 export async function getParaChainStakingMetadata(chain, substrateApi) {
   const chainApi = await substrateApi.isReady;
   const _round = (await chainApi.api.query.parachainStaking.round()).toHuman();
@@ -119,6 +139,81 @@ export async function getParaChainStakingMetadata(chain, substrateApi) {
     unstakingPeriod
   };
 }
+export async function subscribeParaChainNominatorMetadata(chainInfo, address, substrateApi, delegatorState) {
+  const nominationList = [];
+  const unstakingMap = {};
+  let bnTotalActiveStake = BN_ZERO;
+  const _roundInfo = await substrateApi.api.query.parachainStaking.round();
+  const roundInfo = _roundInfo.toPrimitive();
+  const currentRound = roundInfo.current;
+  await Promise.all(delegatorState.delegations.map(async delegation => {
+    const [_delegationScheduledRequests, _identity, _collatorInfo] = await Promise.all([substrateApi.api.query.parachainStaking.delegationScheduledRequests(delegation.owner), substrateApi.api.query.identity.identityOf(delegation.owner), substrateApi.api.query.parachainStaking.candidateInfo(delegation.owner)]);
+    const collatorInfo = _collatorInfo.toPrimitive();
+    const minDelegation = collatorInfo === null || collatorInfo === void 0 ? void 0 : collatorInfo.lowestTopDelegationAmount.toString();
+    const identityInfo = _identity.toHuman();
+    const delegationScheduledRequests = _delegationScheduledRequests.toPrimitive();
+    const identity = parseIdentity(identityInfo);
+    let hasUnstaking = false;
+    let delegationStatus = StakingStatus.NOT_EARNING;
+
+    // parse unstaking info
+    if (delegationScheduledRequests) {
+      for (const scheduledRequest of delegationScheduledRequests) {
+        if (reformatAddress(scheduledRequest.delegator, 0) === reformatAddress(address, 0)) {
+          // add network prefix
+          const isClaimable = scheduledRequest.whenExecutable - currentRound <= 0;
+          const remainingEra = scheduledRequest.whenExecutable - (currentRound + 1);
+          const waitingTime = remainingEra * _STAKING_ERA_LENGTH_MAP[chainInfo.slug];
+          const claimable = Object.values(scheduledRequest.action)[0];
+          unstakingMap[delegation.owner] = {
+            chain: chainInfo.slug,
+            status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
+            validatorAddress: delegation.owner,
+            claimable: claimable.toString(),
+            waitingTime: waitingTime > 0 ? waitingTime : 0
+          };
+          hasUnstaking = true;
+          break; // only handle 1 scheduledRequest per collator
+        }
+      }
+    }
+
+    const bnStake = new BN(delegation.amount);
+    const bnUnstakeBalance = unstakingMap[delegation.owner] ? new BN(unstakingMap[delegation.owner].claimable) : BN_ZERO;
+    const bnActiveStake = bnStake.sub(bnUnstakeBalance);
+    if (bnActiveStake.gt(BN_ZERO) && bnActiveStake.gte(new BN(minDelegation))) {
+      delegationStatus = StakingStatus.EARNING_REWARD;
+    }
+    bnTotalActiveStake = bnTotalActiveStake.add(bnActiveStake);
+    nominationList.push({
+      chain: chainInfo.slug,
+      status: delegationStatus,
+      validatorAddress: delegation.owner,
+      validatorIdentity: identity,
+      activeStake: bnActiveStake.toString(),
+      hasUnstaking,
+      validatorMinStake: collatorInfo.lowestTopDelegationAmount.toString()
+    });
+  }));
+
+  // await Promise.all(nominationList.map(async (nomination) => {
+  //   const _collatorInfo = await substrateApi.api.query.parachainStaking.candidateInfo(nomination.validatorAddress);
+  //   const collatorInfo = _collatorInfo.toPrimitive() as unknown as ParachainStakingCandidateMetadata;
+  //
+  //   nomination.validatorMinStake = collatorInfo.lowestTopDelegationAmount.toString();
+  // }));
+
+  const stakingStatus = getStakingStatusByNominations(bnTotalActiveStake, nominationList);
+  return {
+    chain: chainInfo.slug,
+    type: StakingType.NOMINATED,
+    status: stakingStatus,
+    address: address,
+    activeStake: bnTotalActiveStake.toString(),
+    nominations: nominationList,
+    unstakings: Object.values(unstakingMap)
+  };
+}
 export async function getParaChainNominatorMetadata(chainInfo, address, substrateApi) {
   if (_isChainEvmCompatible(chainInfo) && !isEthereumAddress(address)) {
     return;

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

@@ -1,7 +1,9 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ChainStakingMetadata, NominationPoolInfo, NominatorMetadata, UnstakingInfo, ValidatorInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { PalletNominationPoolsPoolMember } 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 interface PalletStakingNominations {
     targets: string[];
     submittedIn: number;
@@ -21,8 +23,11 @@ export interface PalletStakingStakingLedger {
 export declare function validateRelayUnbondingCondition(amount: string, chainStakingMetadata: ChainStakingMetadata, nominatorMetadata: NominatorMetadata): TransactionError[];
 export declare function validatePoolBondingCondition(chainInfo: _ChainInfo, amount: string, selectedPool: NominationPoolInfo, address: string, chainStakingMetadata: ChainStakingMetadata, nominatorMetadata?: NominatorMetadata): TransactionError[];
 export declare function validateRelayBondingCondition(chainInfo: _ChainInfo, amount: string, selectedValidators: ValidatorInfo[], address: string, chainStakingMetadata: ChainStakingMetadata, nominatorMetadata?: NominatorMetadata): TransactionError[];
+export declare function subscribeRelayChainStakingMetadata(chainInfo: _ChainInfo, substrateApi: _SubstrateApi, callback: (chain: string, rs: ChainStakingMetadata) => void): Promise<Codec>;
 export declare function getRelayChainStakingMetadata(chainInfo: _ChainInfo, substrateApi: _SubstrateApi): Promise<ChainStakingMetadata>;
+export declare function subscribeRelayChainNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi, ledger: PalletStakingStakingLedger): Promise<NominatorMetadata>;
 export declare function getRelayChainNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi): Promise<NominatorMetadata | undefined>;
+export declare function subscribeRelayChainPoolMemberMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi, poolMemberInfo: PalletNominationPoolsPoolMember): Promise<NominatorMetadata>;
 export declare function getRelayChainPoolMemberMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi): Promise<NominatorMetadata | undefined>;
 export declare function getRelayValidatorsInfo(chain: string, substrateApi: _SubstrateApi, decimals: number, chainStakingMetadata: ChainStakingMetadata): Promise<ValidatorInfo[]>;
 export declare function getRelayPoolsInfo(chain: string, substrateApi: _SubstrateApi): Promise<NominationPoolInfo[]>;