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

package/background/KoniTypes.d.ts

@@ -110,8 +110,7 @@ export interface StakingJson {
 }
 export interface StakingRewardJson {
     ready: boolean;
-    slowInterval: Array<StakingRewardItem>;
-    fastInterval: Array<StakingRewardItem>;
+    data: Record<string, StakingRewardItem>;
 }
 export interface PriceJson {
     ready?: boolean;
@@ -902,6 +901,11 @@ export interface AddNetworkRequestExternal {
     chainName: string;
     blockExplorerUrls?: string[];
     requestId?: string;
+    nativeCurrency: {
+        name: string;
+        symbol: string;
+        decimals: number;
+    };
 }
 export interface AddNetworkExternalRequest {
     chainId: string;
@@ -918,6 +922,8 @@ export interface AddTokenRequestExternal {
     name: string;
     symbol: string;
     decimals: number;
+    validated: boolean;
+    contractError: boolean;
 }
 export interface ConfirmationDefinitions {
     addNetworkRequest: [ConfirmationsQueueItem<_NetworkUpsertParams>, ConfirmationResult<null>];
@@ -1070,15 +1076,15 @@ export interface ChainStakingMetadata {
     chain: string;
     type: StakingType;
     era: number;
-    expectedReturn?: number;
-    inflation?: number;
     minJoinNominationPool?: string;
     minStake: string;
-    nominatorCount?: number;
     maxValidatorPerNominator: number;
     maxWithdrawalRequestPerValidator: number;
     allowCancelUnstaking: boolean;
     unstakingPeriod: number;
+    expectedReturn?: number;
+    inflation?: number;
+    nominatorCount?: number;
 }
 export interface NominationInfo {
     chain: string;

package/cjs/constants/index.js

@@ -56,7 +56,7 @@ const CRON_REFRESH_NFT_INTERVAL = 7200000;
 exports.CRON_REFRESH_NFT_INTERVAL = CRON_REFRESH_NFT_INTERVAL;
 const CRON_REFRESH_STAKING_REWARD_INTERVAL = 900000;
 exports.CRON_REFRESH_STAKING_REWARD_INTERVAL = CRON_REFRESH_STAKING_REWARD_INTERVAL;
-const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 45000;
+const CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = 300000;
 exports.CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL = CRON_REFRESH_STAKING_REWARD_FAST_INTERVAL;
 const CRON_REFRESH_HISTORY_INTERVAL = 900000;
 exports.CRON_REFRESH_HISTORY_INTERVAL = CRON_REFRESH_HISTORY_INTERVAL;

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

@@ -10,6 +10,8 @@ exports.getAmplitudeNominatorMetadata = getAmplitudeNominatorMetadata;
 exports.getAmplitudeStakingMetadata = getAmplitudeStakingMetadata;
 exports.getAmplitudeUnbondingExtrinsic = getAmplitudeUnbondingExtrinsic;
 exports.getAmplitudeWithdrawalExtrinsic = getAmplitudeWithdrawalExtrinsic;
+exports.subscribeAmplitudeNominatorMetadata = subscribeAmplitudeNominatorMetadata;
+exports.subscribeAmplitudeStakingMetadata = subscribeAmplitudeStakingMetadata;
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _utils = require("@subwallet/extension-base/koni/api/staking/bonding/utils");
 var _constants = require("@subwallet/extension-base/services/chain-service/constants");
@@ -19,6 +21,30 @@ var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+function subscribeAmplitudeStakingMetadata(chain, substrateApi, callback) {
+  return substrateApi.api.query.parachainStaking.round(_round => {
+    const roundObj = _round.toHuman();
+    const round = (0, _utils2.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 = (_constants._STAKING_ERA_LENGTH_MAP[chain] || _constants._STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
+    const unstakingPeriod = blockDuration * parseInt(unstakingDelay);
+    callback(chain, {
+      chain,
+      type: _KoniTypes.StakingType.NOMINATED,
+      era: round,
+      minStake: minDelegatorStake,
+      maxValidatorPerNominator: parseInt(maxDelegations),
+      maxWithdrawalRequestPerValidator: 1,
+      // by default
+      allowCancelUnstaking: true,
+      unstakingPeriod
+    });
+  });
+}
 async function getAmplitudeStakingMetadata(chain, substrateApi) {
   const chainApi = await substrateApi.isReady;
   const _round = (await chainApi.api.query.parachainStaking.round()).toHuman();
@@ -42,6 +68,63 @@ async function getAmplitudeStakingMetadata(chain, substrateApi) {
     unstakingPeriod
   };
 }
+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 ? (0, _utils.parseIdentity)(identityInfo) : undefined;
+    activeStake = delegatorState.amount.toString();
+    const bnActiveStake = new _util.BN(activeStake);
+    let delegationStatus = _KoniTypes.StakingStatus.NOT_EARNING;
+    if (bnActiveStake.gt(_util.BN_ZERO) && bnActiveStake.gte(new _util.BN(minDelegatorStake))) {
+      delegationStatus = _KoniTypes.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 = (_constants._STAKING_ERA_LENGTH_MAP[chainInfo.slug] || _constants._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 ? _KoniTypes.UnstakingStatus.CLAIMABLE : _KoniTypes.UnstakingStatus.UNLOCKING,
+      claimable: nearestUnstakingAmount.toString(),
+      waitingTime: waitingTime > 0 ? waitingTime : 0,
+      validatorAddress: (delegatorState === null || delegatorState === void 0 ? void 0 : delegatorState.owner) || undefined
+    });
+  }
+  const stakingStatus = (0, _utils.getStakingStatusByNominations)(new _util.BN(activeStake), nominationList);
+  return {
+    chain: chainInfo.slug,
+    type: _KoniTypes.StakingType.NOMINATED,
+    status: stakingStatus,
+    address: address,
+    activeStake: activeStake,
+    nominations: nominationList,
+    unstakings: unstakingList
+  };
+}
 async function getAmplitudeNominatorMetadata(chainInfo, address, substrateApi) {
   if ((0, _utilCrypto.isEthereumAddress)(address)) {
     return;

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

@@ -12,6 +12,8 @@ exports.getAstarStakingMetadata = getAstarStakingMetadata;
 exports.getAstarUnbondingExtrinsic = getAstarUnbondingExtrinsic;
 exports.getAstarWithdrawable = getAstarWithdrawable;
 exports.getAstarWithdrawalExtrinsic = getAstarWithdrawalExtrinsic;
+exports.subscribeAstarNominatorMetadata = subscribeAstarNominatorMetadata;
+exports.subscribeAstarStakingMetadata = subscribeAstarStakingMetadata;
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
 var _utils = require("@subwallet/extension-base/koni/api/staking/bonding/utils");
 var _constants = require("@subwallet/extension-base/services/chain-service/constants");
@@ -22,6 +24,26 @@ var _utilCrypto = require("@polkadot/util-crypto");
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
+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) * _constants._STAKING_ERA_LENGTH_MAP[chain];
+    callback(chain, {
+      chain,
+      type: _KoniTypes.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
+    });
+  });
+}
 async function getAstarStakingMetadata(chain, substrateApi) {
   const aprPromise = new Promise(function (resolve) {
     (0, _crossFetch.default)(`https://api.astar.network/api/v1/${chain}/dapps-staking/apr`, {
@@ -57,6 +79,87 @@ async function getAstarStakingMetadata(chain, substrateApi) {
     unstakingPeriod
   };
 }
+async function subscribeAstarNominatorMetadata(chainInfo, address, substrateApi, ledger) {
+  const nominationList = [];
+  const unstakingList = [];
+  const allDappsReq = new Promise(function (resolve) {
+    (0, _crossFetch.default)(`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 = _util.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 _util.BN(currentStake);
+      if (bnCurrentStake.gt(_util.BN_ZERO)) {
+        const dappStakingStatus = bnCurrentStake.gt(_util.BN_ZERO) && bnCurrentStake.gte(new _util.BN(minDelegatorStake)) ? _KoniTypes.StakingStatus.EARNING_REWARD : _KoniTypes.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 * _constants._STAKING_ERA_LENGTH_MAP[chainInfo.slug];
+      unstakingList.push({
+        chain: chainInfo.slug,
+        status: isClaimable ? _KoniTypes.UnstakingStatus.CLAIMABLE : _KoniTypes.UnstakingStatus.UNLOCKING,
+        claimable: unlockingChunk.amount.toString(),
+        waitingTime: waitingTime > 0 ? waitingTime : 0
+      });
+    }
+  }
+  if (nominationList.length === 0 && unstakingList.length === 0) {
+    return {
+      chain: chainInfo.slug,
+      type: _KoniTypes.StakingType.NOMINATED,
+      address,
+      status: _KoniTypes.StakingStatus.NOT_STAKING,
+      activeStake: '0',
+      nominations: [],
+      unstakings: []
+    };
+  }
+  const stakingStatus = (0, _utils.getStakingStatusByNominations)(bnTotalActiveStake, nominationList);
+  return {
+    chain: chainInfo.slug,
+    type: _KoniTypes.StakingType.NOMINATED,
+    address: address,
+    activeStake: bnTotalActiveStake.toString(),
+    nominations: nominationList,
+    unstakings: unstakingList,
+    status: stakingStatus
+  };
+}
 async function getAstarNominatorMetadata(chainInfo, address, substrateApi) {
   if ((0, _utilCrypto.isEthereumAddress)(address)) {
     return;
@@ -181,7 +284,7 @@ async function getAstarDappsInfo(networkKey, substrateApi) {
     allDappsInfo.push({
       commission: 0,
       expectedReturn: 0,
-      address: dappAddress.toLowerCase(),
+      address: (0, _utilCrypto.isEthereumAddress)(dappAddress) ? dappAddress.toLowerCase() : dappAddress,
       totalStake: totalStake,
       ownStake: '0',
       otherStake: totalStake.toString(),

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

@@ -12,6 +12,7 @@ exports.getNominatorMetadata = getNominatorMetadata;
 exports.getUnbondingExtrinsic = getUnbondingExtrinsic;
 exports.getValidatorsInfo = getValidatorsInfo;
 exports.getWithdrawalExtrinsic = getWithdrawalExtrinsic;
+exports.subscribeEssentialChainStakingMetadata = subscribeEssentialChainStakingMetadata;
 exports.validateBondingCondition = validateBondingCondition;
 exports.validateUnbondingCondition = validateUnbondingCondition;
 var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
@@ -117,4 +118,38 @@ async function getCancelWithdrawalExtrinsic(substrateApi, chain, selectedUnstaki
     return (0, _paraChain.getParaCancelWithdrawalExtrinsic)(substrateApi, selectedUnstaking);
   }
   return (0, _relayChain.getRelayCancelWithdrawalExtrinsic)(substrateApi, selectedUnstaking);
+}
+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 (_constants._STAKING_CHAIN_GROUP.astar.includes(chainInfo.slug)) {
+      const unsub = await (0, _astar.subscribeAstarStakingMetadata)(chainInfo.slug, substrateApi, callback);
+
+      // @ts-ignore
+      unsubList.push(unsub);
+    } else if (_constants._STAKING_CHAIN_GROUP.para.includes(chainInfo.slug)) {
+      const unsub = await (0, _paraChain.subscribeParaChainStakingMetadata)(chainInfo.slug, substrateApi, callback);
+
+      // @ts-ignore
+      unsubList.push(unsub);
+    } else if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chainInfo.slug)) {
+      const unsub = await (0, _amplitude.subscribeAmplitudeStakingMetadata)(chainInfo.slug, substrateApi, callback);
+
+      // @ts-ignore
+      unsubList.push(unsub);
+    } else if (_constants._STAKING_CHAIN_GROUP.relay.includes(chainInfo.slug)) {
+      const unsub = await (0, _relayChain.subscribeRelayChainStakingMetadata)(chainInfo, substrateApi, callback);
+
+      // @ts-ignore
+      unsubList.push(unsub);
+    }
+  });
+  return () => {
+    unsubList.forEach(unsub => {
+      unsub && unsub();
+    });
+  };
 }

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

@@ -12,6 +12,8 @@ exports.getParaWithdrawalExtrinsic = getParaWithdrawalExtrinsic;
 exports.getParachainCollatorsInfo = getParachainCollatorsInfo;
 exports.getTuringCancelCompoundingExtrinsic = getTuringCancelCompoundingExtrinsic;
 exports.getTuringCompoundExtrinsic = getTuringCompoundExtrinsic;
+exports.subscribeParaChainNominatorMetadata = subscribeParaChainNominatorMetadata;
+exports.subscribeParaChainStakingMetadata = subscribeParaChainStakingMetadata;
 exports.validateParaChainBondingCondition = validateParaChainBondingCondition;
 exports.validateParaChainUnbondingCondition = validateParaChainUnbondingCondition;
 var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
@@ -97,6 +99,26 @@ function validateParaChainBondingCondition(chainInfo, amount, selectedCollators,
   }
   return errors;
 }
+function subscribeParaChainStakingMetadata(chain, substrateApi, callback) {
+  return substrateApi.api.query.parachainStaking.round(_round => {
+    const roundObj = _round.toHuman();
+    const round = (0, _utils3.parseRawNumber)(roundObj.current);
+    const maxDelegations = substrateApi.api.consts.parachainStaking.maxDelegationsPerDelegator.toString();
+    const unstakingDelay = substrateApi.api.consts.parachainStaking.delegationBondLessDelay.toString();
+    const unstakingPeriod = parseInt(unstakingDelay) * (_constants._STAKING_ERA_LENGTH_MAP[chain] || _constants._STAKING_ERA_LENGTH_MAP.default);
+    callback(chain, {
+      chain,
+      type: _KoniTypes.StakingType.NOMINATED,
+      era: round,
+      minStake: '0',
+      maxValidatorPerNominator: parseInt(maxDelegations),
+      maxWithdrawalRequestPerValidator: 1,
+      // by default
+      allowCancelUnstaking: true,
+      unstakingPeriod
+    });
+  });
+}
 async function getParaChainStakingMetadata(chain, substrateApi) {
   const chainApi = await substrateApi.isReady;
   const _round = (await chainApi.api.query.parachainStaking.round()).toHuman();
@@ -135,6 +157,81 @@ async function getParaChainStakingMetadata(chain, substrateApi) {
     unstakingPeriod
   };
 }
+async function subscribeParaChainNominatorMetadata(chainInfo, address, substrateApi, delegatorState) {
+  const nominationList = [];
+  const unstakingMap = {};
+  let bnTotalActiveStake = _util.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 = (0, _utils.parseIdentity)(identityInfo);
+    let hasUnstaking = false;
+    let delegationStatus = _KoniTypes.StakingStatus.NOT_EARNING;
+
+    // parse unstaking info
+    if (delegationScheduledRequests) {
+      for (const scheduledRequest of delegationScheduledRequests) {
+        if ((0, _utils3.reformatAddress)(scheduledRequest.delegator, 0) === (0, _utils3.reformatAddress)(address, 0)) {
+          // add network prefix
+          const isClaimable = scheduledRequest.whenExecutable - currentRound <= 0;
+          const remainingEra = scheduledRequest.whenExecutable - (currentRound + 1);
+          const waitingTime = remainingEra * _constants._STAKING_ERA_LENGTH_MAP[chainInfo.slug];
+          const claimable = Object.values(scheduledRequest.action)[0];
+          unstakingMap[delegation.owner] = {
+            chain: chainInfo.slug,
+            status: isClaimable ? _KoniTypes.UnstakingStatus.CLAIMABLE : _KoniTypes.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 _util.BN(delegation.amount);
+    const bnUnstakeBalance = unstakingMap[delegation.owner] ? new _util.BN(unstakingMap[delegation.owner].claimable) : _util.BN_ZERO;
+    const bnActiveStake = bnStake.sub(bnUnstakeBalance);
+    if (bnActiveStake.gt(_util.BN_ZERO) && bnActiveStake.gte(new _util.BN(minDelegation))) {
+      delegationStatus = _KoniTypes.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 = (0, _utils.getStakingStatusByNominations)(bnTotalActiveStake, nominationList);
+  return {
+    chain: chainInfo.slug,
+    type: _KoniTypes.StakingType.NOMINATED,
+    status: stakingStatus,
+    address: address,
+    activeStake: bnTotalActiveStake.toString(),
+    nominations: nominationList,
+    unstakings: Object.values(unstakingMap)
+  };
+}
 async function getParaChainNominatorMetadata(chainInfo, address, substrateApi) {
   if ((0, _utils2._isChainEvmCompatible)(chainInfo) && !(0, _utilCrypto.isEthereumAddress)(address)) {
     return;