@subwallet/extension-base 0.8.3-2 → 1.0.1

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

@@ -0,0 +1,222 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StakingAction = exports.PalletParachainStakingRequestType = void 0;
+exports.calcInflationRewardCurve = calcInflationRewardCurve;
+exports.calcInflationUniformEraPayout = calcInflationUniformEraPayout;
+exports.calculateAlephZeroValidatorReturn = calculateAlephZeroValidatorReturn;
+exports.calculateChainStakedReturn = calculateChainStakedReturn;
+exports.calculateInflation = calculateInflation;
+exports.calculateValidatorStakedReturn = calculateValidatorStakedReturn;
+exports.getBondedValidators = getBondedValidators;
+exports.getCommission = getCommission;
+exports.getInflationParams = getInflationParams;
+exports.getParaCurrentInflation = getParaCurrentInflation;
+exports.getStakingAvailableActions = getStakingAvailableActions;
+exports.getWithdrawalInfo = getWithdrawalInfo;
+exports.isActionFromValidator = isActionFromValidator;
+exports.isShowNominationByValidator = isShowNominationByValidator;
+exports.isUnstakeAll = isUnstakeAll;
+exports.parseIdentity = parseIdentity;
+exports.transformPoolName = transformPoolName;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/utils");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+let PalletParachainStakingRequestType;
+exports.PalletParachainStakingRequestType = PalletParachainStakingRequestType;
+(function (PalletParachainStakingRequestType) {
+  PalletParachainStakingRequestType["REVOKE"] = "revoke";
+  PalletParachainStakingRequestType["DECREASE"] = "decrease";
+  PalletParachainStakingRequestType["BOND_LESS"] = "bondLess";
+})(PalletParachainStakingRequestType || (exports.PalletParachainStakingRequestType = PalletParachainStakingRequestType = {}));
+function transformPoolName(input) {
+  return input.replace(/[^\x20-\x7E]/g, '');
+}
+function parseIdentity(identityInfo) {
+  let identity;
+  if (identityInfo !== null) {
+    var _identityInfo$info, _identityInfo$info$di, _identityInfo$info2, _identityInfo$info2$w, _identityInfo$info3, _identityInfo$info3$r, _identityInfo$info4, _identityInfo$info4$t;
+    const displayName = identityInfo === null || identityInfo === void 0 ? void 0 : (_identityInfo$info = identityInfo.info) === null || _identityInfo$info === void 0 ? void 0 : (_identityInfo$info$di = _identityInfo$info.display) === null || _identityInfo$info$di === void 0 ? void 0 : _identityInfo$info$di.Raw;
+    const web = identityInfo === null || identityInfo === void 0 ? void 0 : (_identityInfo$info2 = identityInfo.info) === null || _identityInfo$info2 === void 0 ? void 0 : (_identityInfo$info2$w = _identityInfo$info2.web) === null || _identityInfo$info2$w === void 0 ? void 0 : _identityInfo$info2$w.Raw;
+    const riot = identityInfo === null || identityInfo === void 0 ? void 0 : (_identityInfo$info3 = identityInfo.info) === null || _identityInfo$info3 === void 0 ? void 0 : (_identityInfo$info3$r = _identityInfo$info3.riot) === null || _identityInfo$info3$r === void 0 ? void 0 : _identityInfo$info3$r.Raw;
+    const twitter = identityInfo === null || identityInfo === void 0 ? void 0 : (_identityInfo$info4 = identityInfo.info) === null || _identityInfo$info4 === void 0 ? void 0 : (_identityInfo$info4$t = _identityInfo$info4.twitter) === null || _identityInfo$info4$t === void 0 ? void 0 : _identityInfo$info4$t.Raw;
+    if (displayName && !displayName.startsWith('0x')) {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+      identity = displayName;
+    } else {
+      identity = twitter || web || riot;
+    }
+  }
+  return identity;
+}
+function getInflationParams(networkKey) {
+  return _constants._KNOWN_CHAIN_INFLATION_PARAMS[networkKey] || _constants._SUBSTRATE_DEFAULT_INFLATION_PARAMS;
+}
+function calcInflationUniformEraPayout(totalIssuance, yearlyInflationInTokens) {
+  const totalIssuanceInTokens = totalIssuance.div(_util.BN_BILLION).div(_util.BN_THOUSAND).toNumber();
+  return totalIssuanceInTokens === 0 ? 0.0 : yearlyInflationInTokens / totalIssuanceInTokens;
+}
+function calcInflationRewardCurve(minInflation, stakedFraction, idealStake, idealInterest, falloff) {
+  return minInflation + (stakedFraction <= idealStake ? stakedFraction * (idealInterest - minInflation / idealStake) : (idealInterest * idealStake - minInflation) * Math.pow(2, (idealStake - stakedFraction) / falloff));
+}
+function calculateInflation(totalEraStake, totalIssuance, numAuctions, networkKey) {
+  const inflationParams = getInflationParams(networkKey);
+  const {
+    auctionAdjust,
+    auctionMax,
+    falloff,
+    maxInflation,
+    minInflation,
+    stakeTarget
+  } = inflationParams;
+  const idealStake = stakeTarget - Math.min(auctionMax, numAuctions) * auctionAdjust;
+  const idealInterest = maxInflation / idealStake;
+  const stakedFraction = totalEraStake.mul(_util.BN_MILLION).div(totalIssuance).toNumber() / _util.BN_MILLION.toNumber();
+  if (_constants._STAKING_CHAIN_GROUP.aleph.includes(networkKey)) {
+    if (inflationParams.yearlyInflationInTokens) {
+      return 100 * calcInflationUniformEraPayout(totalIssuance, inflationParams.yearlyInflationInTokens);
+    } else {
+      return 100 * calcInflationRewardCurve(minInflation, stakedFraction, idealStake, idealInterest, falloff);
+    }
+  } else {
+    return 100 * (minInflation + (stakedFraction <= idealStake ? stakedFraction * (idealInterest - minInflation / idealStake) : (idealInterest * idealStake - minInflation) * Math.pow(2, (idealStake - stakedFraction) / falloff)));
+  }
+}
+function calculateChainStakedReturn(inflation, totalEraStake, totalIssuance, networkKey) {
+  const stakedFraction = totalEraStake.mul(_util.BN_MILLION).div(totalIssuance).toNumber() / _util.BN_MILLION.toNumber();
+  let stakedReturn = inflation / stakedFraction;
+  if (_constants._STAKING_CHAIN_GROUP.aleph.includes(networkKey)) {
+    stakedReturn *= 0.9; // 10% goes to treasury
+  }
+
+  return stakedReturn;
+}
+function calculateAlephZeroValidatorReturn(chainStakedReturn, commission) {
+  return chainStakedReturn * (100 - commission) / 100;
+}
+function calculateValidatorStakedReturn(chainStakedReturn, totalValidatorStake, avgStake, commission) {
+  const bnAdjusted = avgStake.mul(_util.BN_HUNDRED).div(totalValidatorStake);
+  const adjusted = bnAdjusted.toNumber() * chainStakedReturn;
+  const stakedReturn = (adjusted > Number.MAX_SAFE_INTEGER ? Number.MAX_SAFE_INTEGER : adjusted) / 100;
+  return stakedReturn * (100 - commission) / 100; // Deduct commission
+}
+
+function getCommission(commissionString) {
+  return parseFloat(commissionString.split('%')[0]); // Example: 12%
+}
+
+function getParaCurrentInflation(totalStaked, inflationConfig) {
+  // read more at https://hackmd.io/@sbAqOuXkRvyiZPOB3Ryn6Q/Sypr3ZJh5
+  const expectMin = (0, _utils.parseRawNumber)(inflationConfig.expect.min);
+  const expectMax = (0, _utils.parseRawNumber)(inflationConfig.expect.max);
+  if (totalStaked < expectMin) {
+    const inflationString = inflationConfig.annual.min.split('%')[0];
+    return parseFloat(inflationString);
+  } else if (totalStaked > expectMax) {
+    const inflationString = inflationConfig.annual.max.split('%')[0];
+    return parseFloat(inflationString);
+  }
+  const inflationString = inflationConfig.annual.ideal.split('%')[0];
+  return parseFloat(inflationString);
+}
+// validations and check conditions
+function isShowNominationByValidator(chain) {
+  if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+    return 'showByValue';
+  } else if (_constants._STAKING_CHAIN_GROUP.astar.includes(chain)) {
+    return 'mixed';
+  } else if (_constants._STAKING_CHAIN_GROUP.para.includes(chain)) {
+    return 'showByValidator';
+  }
+  return 'showByValue';
+}
+function getBondedValidators(nominations) {
+  const bondedValidators = [];
+  let nominationCount = 0;
+  for (const nomination of nominations) {
+    const bnActiveStake = new _util.BN(nomination.activeStake);
+    if (bnActiveStake.gt(_util.BN_ZERO)) {
+      nominationCount += 1;
+      bondedValidators.push((0, _utils.reformatAddress)(nomination.validatorAddress, 0));
+    }
+  }
+  return {
+    nominationCount,
+    bondedValidators
+  };
+}
+function isUnstakeAll(selectedValidator, nominations, unstakeAmount) {
+  let isUnstakeAll = false;
+  for (const nomination of nominations) {
+    if (nomination.validatorAddress === selectedValidator) {
+      if (unstakeAmount === nomination.activeStake) {
+        isUnstakeAll = true;
+      }
+      break;
+    }
+  }
+  return isUnstakeAll;
+}
+let StakingAction;
+exports.StakingAction = StakingAction;
+(function (StakingAction) {
+  StakingAction["STAKE"] = "STAKE";
+  StakingAction["UNSTAKE"] = "UNSTAKE";
+  StakingAction["WITHDRAW"] = "WITHDRAW";
+  StakingAction["CLAIM_REWARD"] = "CLAIM_REWARD";
+  StakingAction["CANCEL_UNSTAKE"] = "CANCEL_UNSTAKE";
+})(StakingAction || (exports.StakingAction = StakingAction = {}));
+function getStakingAvailableActions(nominatorMetadata) {
+  const result = [StakingAction.STAKE];
+  const bnActiveStake = new _util.BN(nominatorMetadata.activeStake);
+  if (nominatorMetadata.activeStake && bnActiveStake.gt(_util.BN_ZERO)) {
+    result.push(StakingAction.UNSTAKE);
+    const isChainAllowClaimReward = _constants._STAKING_CHAIN_GROUP.amplitude.includes(nominatorMetadata.chain) || _constants._STAKING_CHAIN_GROUP.astar.includes(nominatorMetadata.chain);
+    if (nominatorMetadata.type === _KoniTypes.StakingType.POOLED || isChainAllowClaimReward) {
+      result.push(StakingAction.CLAIM_REWARD);
+    }
+  }
+  if (nominatorMetadata.unstakings.length > 0) {
+    result.push(StakingAction.CANCEL_UNSTAKE);
+    let hasClaimable = false;
+    for (const unstaking of nominatorMetadata.unstakings) {
+      if (unstaking.status === _KoniTypes.UnstakingStatus.CLAIMABLE) {
+        hasClaimable = true;
+        break;
+      }
+    }
+    if (hasClaimable) {
+      result.push(StakingAction.WITHDRAW);
+    }
+  }
+  return result;
+}
+function isActionFromValidator(stakingType, chain) {
+  if (stakingType === _KoniTypes.StakingType.POOLED) {
+    return false;
+  }
+  if (_constants._STAKING_CHAIN_GROUP.astar.includes(chain)) {
+    return true;
+  } else if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+    return true;
+  } else if (_constants._STAKING_CHAIN_GROUP.para.includes(chain)) {
+    return true;
+  }
+  return false;
+}
+function getWithdrawalInfo(nominatorMetadata) {
+  const unstakings = nominatorMetadata.unstakings;
+  let result;
+  for (const unstaking of unstakings) {
+    if (unstaking.status === _KoniTypes.UnstakingStatus.CLAIMABLE) {
+      result = unstaking; // only get the first withdrawal
+      break;
+    }
+  }
+  return result;
+}

package/cjs/koni/api/staking/config.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SUBSQUID_ENDPOINTS = exports.SUBQUERY_ENDPOINTS = exports.INDEXER_SUPPORTED_STAKING_CHAINS = void 0;
+var _chainList = require("@subwallet/chain-list");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const SUBSQUID_ENDPOINTS = {
+  [_chainList.COMMON_CHAIN_SLUGS.KUSAMA]: 'https://squid.subsquid.io/kusama-explorer/graphql',
+  [_chainList.COMMON_CHAIN_SLUGS.POLKADOT]: 'https://squid.subsquid.io/polkadot-explorer/graphql',
+  [_chainList.COMMON_CHAIN_SLUGS.ASTAR]: 'https://squid.subsquid.io/astar-explorer/graphql',
+  [_chainList.COMMON_CHAIN_SLUGS.MOONRIVER]: 'https://squid.subsquid.io/moonriver-explorer/graphql',
+  [_chainList.COMMON_CHAIN_SLUGS.MOONBEAM]: 'https://squid.subsquid.io/moonbeam-explorer/graphql'
+};
+exports.SUBSQUID_ENDPOINTS = SUBSQUID_ENDPOINTS;
+const INDEXER_SUPPORTED_STAKING_CHAINS = [_chainList.COMMON_CHAIN_SLUGS.POLKADOT, _chainList.COMMON_CHAIN_SLUGS.KUSAMA, _chainList.COMMON_CHAIN_SLUGS.ASTAR, _chainList.COMMON_CHAIN_SLUGS.MOONRIVER, _chainList.COMMON_CHAIN_SLUGS.MOONBEAM];
+exports.INDEXER_SUPPORTED_STAKING_CHAINS = INDEXER_SUPPORTED_STAKING_CHAINS;
+const SUBQUERY_ENDPOINTS = {
+  polkadot: 'https://api.subquery.network/sq/nova-wallet/nova-westend',
+  kusama: 'https://api.subquery.network/sq/nova-wallet/nova-kusama',
+  westend: 'https://api.subquery.network/sq/nova-wallet/nova-westend',
+  picasso: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-picasso',
+  calamari: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-calamari',
+  khala: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-khala',
+  parallel: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-parallel',
+  bifrost: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-bifrost',
+  clover: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-clover',
+  basilisk: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-basilisk',
+  acala: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-acala',
+  astar: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-astar',
+  karura: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-karura',
+  altair: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-altair',
+  kilt: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-kilt',
+  robonomics: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-robonomics',
+  statemint: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-statemint',
+  quartz: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-quartz',
+  zeigeist: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-zeitgeist',
+  shiden: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-shiden',
+  statemine: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-statemine',
+  moonbeam: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-moonbeam',
+  moonriver: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-moonriver',
+  pioneer: 'https://api.subquery.network/sq/nova-wallet/nova-wallet-bit-country'
+};
+exports.SUBQUERY_ENDPOINTS = SUBQUERY_ENDPOINTS;

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

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getNominationStakingRewardData = getNominationStakingRewardData;
+exports.getPoolingStakingRewardData = getPoolingStakingRewardData;
+exports.stakingOnChainApi = stakingOnChainApi;
+var _paraChain = require("@subwallet/extension-base/koni/api/staking/paraChain");
+var _relayChain = require("@subwallet/extension-base/koni/api/staking/relayChain");
+var _subsquidStaking = require("@subwallet/extension-base/koni/api/staking/subsquidStaking");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+function stakingOnChainApi(addresses, substrateApiMap, callback, chainInfoMap) {
+  const filteredApiMap = [];
+  const [substrateAddresses, evmAddresses] = (0, _utils2.categoryAddresses)(addresses);
+  Object.entries(chainInfoMap).forEach(_ref => {
+    let [networkKey, chainInfo] = _ref;
+    if (_constants._PURE_EVM_CHAINS.indexOf(networkKey) < 0 && (0, _utils._isChainSupportSubstrateStaking)(chainInfo)) {
+      filteredApiMap.push({
+        chain: networkKey,
+        api: substrateApiMap[networkKey]
+      });
+    }
+  });
+  const unsubList = [];
+
+  // eslint-disable-next-line @typescript-eslint/no-misused-promises
+  filteredApiMap.forEach(async _ref2 => {
+    let {
+      api: apiPromise,
+      chain
+    } = _ref2;
+    const parentApi = await apiPromise.isReady;
+    const useAddresses = (0, _utils._isChainEvmCompatible)(chainInfoMap[chain]) ? evmAddresses : substrateAddresses;
+    if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+      const unsub = await (0, _paraChain.getAmplitudeStakingOnChain)(parentApi, useAddresses, chainInfoMap, chain, callback);
+      unsubList.push(unsub);
+    } else if (_constants._STAKING_CHAIN_GROUP.astar.includes(chain)) {
+      const unsub = await (0, _paraChain.getAstarStakingOnChain)(parentApi, useAddresses, chainInfoMap, chain, callback);
+      unsubList.push(unsub);
+    } else if (_constants._STAKING_CHAIN_GROUP.para.includes(chain)) {
+      const unsub = await (0, _paraChain.getParaStakingOnChain)(parentApi, useAddresses, chainInfoMap, chain, callback);
+      unsubList.push(unsub);
+    } else if (_constants._STAKING_CHAIN_GROUP.relay.includes(chain)) {
+      const unsub = await (0, _relayChain.getRelayStakingOnChain)(parentApi, useAddresses, chainInfoMap, chain, callback);
+      unsubList.push(unsub);
+    }
+    if (_constants._STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
+      const unsub = await (0, _relayChain.getRelayPoolingOnChain)(parentApi, useAddresses, chainInfoMap, chain, callback);
+      unsubList.push(unsub);
+    }
+  });
+  return () => {
+    unsubList.forEach(unsub => {
+      unsub && unsub();
+    });
+  };
+}
+async function getNominationStakingRewardData(addresses, chainInfoMap) {
+  // might retrieve from other sources
+  return await (0, _subsquidStaking.getAllSubsquidStaking)(addresses, chainInfoMap);
+}
+async function getPoolingStakingRewardData(addresses, networkMap, dotSamaApiMap) {
+  const activeNetworks = [];
+  Object.keys(networkMap).forEach(key => {
+    activeNetworks.push(key);
+  });
+  if (activeNetworks.length === 0) {
+    return [];
+  }
+  return await (0, _relayChain.getNominationPoolReward)(addresses, networkMap, dotSamaApiMap);
+}

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

@@ -0,0 +1,226 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAmplitudeStakingOnChain = getAmplitudeStakingOnChain;
+exports.getAmplitudeUnclaimedStakingReward = getAmplitudeUnclaimedStakingReward;
+exports.getAstarStakingOnChain = getAstarStakingOnChain;
+exports.getParaStakingOnChain = getParaStakingOnChain;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+function getSingleStakingAmplitude(parentApi, address, networks, chain, callback) {
+  return parentApi.api.queryMulti([[parentApi.api.query.parachainStaking.delegatorState, address], [parentApi.api.query.parachainStaking.unstaking, address]], _ref => {
+    let [_delegatorState, _unstaking] = _ref;
+    const _stakingData = _delegatorState.toHuman();
+    const _unstakingData = _unstaking.toHuman();
+    let _activeBalance = '0';
+    if (_stakingData !== null) {
+      _activeBalance = _stakingData.amount || _stakingData.total;
+      _activeBalance = _activeBalance.replaceAll(',', '');
+    }
+    const activeBalance = new _util.BN(_activeBalance);
+    let unstakingBalance = _util.BN_ZERO;
+    if (_unstakingData !== null) {
+      Object.values(_unstakingData).forEach(_unstakingAmount => {
+        const bnUnstakingAmount = new _util.BN(_unstakingAmount.replaceAll(',', ''));
+        unstakingBalance = unstakingBalance.add(bnUnstakingAmount);
+      });
+    }
+    const totalBalance = activeBalance.add(unstakingBalance);
+    const {
+      symbol
+    } = (0, _utils._getChainNativeTokenBasicInfo)(networks[chain]);
+    const stakingItem = {
+      name: networks[chain].name,
+      chain: chain,
+      balance: totalBalance.toString(),
+      activeBalance: activeBalance.toString(),
+      unlockingBalance: unstakingBalance.toString(),
+      nativeToken: symbol,
+      unit: symbol,
+      state: _KoniTypes.APIItemState.READY,
+      type: _KoniTypes.StakingType.NOMINATED,
+      address
+    };
+    callback(chain, stakingItem);
+  });
+}
+function getMultiStakingAmplitude(parentApi, useAddresses, networks, chain, callback) {
+  return parentApi.api.query.parachainStaking.delegatorState.multi(useAddresses, async ledgers => {
+    if (ledgers) {
+      const _unstakingStates = await parentApi.api.query.parachainStaking.unstaking.multi(useAddresses);
+      for (let i = 0; i < ledgers.length; i++) {
+        const ledger = ledgers[i];
+        const _unstakingData = _unstakingStates[i].toHuman();
+        const owner = (0, _utils2.reformatAddress)(useAddresses[i], 42);
+        const _stakingData = ledger.toHuman();
+        let _activeBalance = '0';
+        if (_stakingData !== null) {
+          _activeBalance = _stakingData.amount || _stakingData.total;
+          _activeBalance = _activeBalance.replaceAll(',', '');
+        }
+        const activeBalance = new _util.BN(_activeBalance);
+        let unstakingBalance = _util.BN_ZERO;
+        if (_unstakingData !== null) {
+          Object.values(_unstakingData).forEach(_unstakingAmount => {
+            const bnUnstakingAmount = new _util.BN(_unstakingAmount.replaceAll(',', ''));
+            unstakingBalance = unstakingBalance.add(bnUnstakingAmount);
+          });
+        }
+        const totalBalance = activeBalance.add(unstakingBalance);
+        const {
+          symbol
+        } = (0, _utils._getChainNativeTokenBasicInfo)(networks[chain]);
+        const stakingItem = {
+          name: networks[chain].name,
+          chain: chain,
+          balance: totalBalance.toString(),
+          activeBalance: activeBalance.toString(),
+          unlockingBalance: unstakingBalance.toString(),
+          nativeToken: symbol,
+          unit: symbol,
+          state: _KoniTypes.APIItemState.READY,
+          type: _KoniTypes.StakingType.NOMINATED,
+          address: owner
+        };
+        callback(chain, stakingItem);
+      }
+    }
+  });
+}
+function getAmplitudeStakingOnChain(parentApi, useAddresses, networks, chain, callback) {
+  if (useAddresses.length === 1) {
+    return getSingleStakingAmplitude(parentApi, useAddresses[0], networks, chain, callback);
+  }
+  return getMultiStakingAmplitude(parentApi, useAddresses, networks, chain, callback);
+}
+async function getAmplitudeUnclaimedStakingReward(substrateApiMap, addresses, networks, chains) {
+  if (chains.length === 0) {
+    return [];
+  }
+  const useAddresses = [];
+  addresses.forEach(address => {
+    if (!(0, _utilCrypto.isEthereumAddress)(address)) {
+      useAddresses.push(address);
+    }
+  });
+  const unclaimedRewardList = [];
+  await Promise.all(chains.map(async chain => {
+    if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain) && !_constants._STAKING_CHAIN_GROUP.kilt.includes(chain)) {
+      const networkInfo = networks[chain];
+      const apiProps = await substrateApiMap[chain].isReady;
+      await Promise.all(useAddresses.map(async address => {
+        const _unclaimedReward = await apiProps.api.query.parachainStaking.rewards(address);
+        const unclaimedReward = _unclaimedReward.toString();
+        const rewardItem = {
+          chain,
+          name: networkInfo.name,
+          state: _KoniTypes.APIItemState.READY,
+          type: _KoniTypes.StakingType.NOMINATED,
+          address: (0, _utils2.reformatAddress)(address, 42),
+          unclaimedReward
+        };
+        unclaimedRewardList.push(rewardItem);
+      }));
+    }
+  }));
+  return unclaimedRewardList;
+}
+function getParaStakingOnChain(parentApi, useAddresses, networks, chain, callback) {
+  const {
+    symbol
+  } = (0, _utils._getChainNativeTokenBasicInfo)(networks[chain]);
+  return parentApi.api.query.parachainStaking.delegatorState.multi(useAddresses, ledgers => {
+    if (ledgers) {
+      for (let i = 0; i < ledgers.length; i++) {
+        const ledger = ledgers[i];
+        const owner = (0, _utils2.reformatAddress)(useAddresses[i], 42);
+        const data = ledger.toHuman();
+        if (data !== null) {
+          let _totalBalance = data.total;
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+          let _unlockingBalance = data.lessTotal ? data.lessTotal : data.requests.lessTotal;
+          _totalBalance = _totalBalance.replaceAll(',', '');
+          _unlockingBalance = _unlockingBalance.replaceAll(',', '');
+          const totalBalance = new _util.BN(_totalBalance);
+          const unlockingBalance = new _util.BN(_unlockingBalance);
+          const activeBalance = totalBalance.sub(unlockingBalance);
+          const stakingItem = {
+            name: networks[chain].name,
+            chain: chain,
+            balance: totalBalance.toString(),
+            activeBalance: activeBalance.toString(),
+            unlockingBalance: unlockingBalance.toString(),
+            nativeToken: symbol,
+            unit: symbol,
+            state: _KoniTypes.APIItemState.READY,
+            type: _KoniTypes.StakingType.NOMINATED,
+            address: owner
+          };
+          callback(chain, stakingItem);
+        } else {
+          const stakingItem = {
+            name: networks[chain].name,
+            chain: chain,
+            balance: '0',
+            activeBalance: '0',
+            unlockingBalance: '0',
+            nativeToken: symbol,
+            unit: symbol,
+            state: _KoniTypes.APIItemState.READY,
+            type: _KoniTypes.StakingType.NOMINATED,
+            address: owner
+          };
+          callback(chain, stakingItem);
+        }
+      }
+    }
+  });
+}
+function getAstarStakingOnChain(parentApi, useAddresses, networks, chain, callback) {
+  const {
+    symbol
+  } = (0, _utils._getChainNativeTokenBasicInfo)(networks[chain]);
+  return parentApi.api.query.dappsStaking.ledger.multi(useAddresses, ledgers => {
+    if (ledgers) {
+      for (let i = 0; i < ledgers.length; i++) {
+        let bnUnlockingBalance = _util.BN_ZERO;
+        const owner = (0, _utils2.reformatAddress)(useAddresses[i], 42);
+        const ledger = ledgers[i];
+        const data = ledger.toHuman();
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+        const unlockingChunks = data.unbondingInfo.unlockingChunks;
+        const _totalStake = data.locked;
+        for (const chunk of unlockingChunks) {
+          const bnChunk = new _util.BN(chunk.amount.replaceAll(',', ''));
+          bnUnlockingBalance = bnUnlockingBalance.add(bnChunk);
+        }
+        const bnTotalStake = new _util.BN(_totalStake.replaceAll(',', ''));
+        const bnActiveStake = bnTotalStake.sub(bnUnlockingBalance);
+        const stakingItem = {
+          name: networks[chain].name,
+          chain: chain,
+          balance: bnTotalStake.toString(),
+          activeBalance: bnActiveStake.toString(),
+          unlockingBalance: bnUnlockingBalance.toString(),
+          nativeToken: symbol,
+          unit: symbol,
+          state: _KoniTypes.APIItemState.READY,
+          type: _KoniTypes.StakingType.NOMINATED,
+          address: owner
+        };
+
+        // eslint-disable-next-line node/no-callback-literal
+        callback(chain, stakingItem);
+      }
+    }
+  });
+}