@subwallet/extension-base 0.8.3-2 → 1.0.1

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

@@ -0,0 +1,254 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getParaBondingExtrinsic = getParaBondingExtrinsic;
+exports.getParaCancelWithdrawalExtrinsic = getParaCancelWithdrawalExtrinsic;
+exports.getParaChainNominatorMetadata = getParaChainNominatorMetadata;
+exports.getParaChainStakingMetadata = getParaChainStakingMetadata;
+exports.getParaUnbondingExtrinsic = getParaUnbondingExtrinsic;
+exports.getParaWithdrawalExtrinsic = getParaWithdrawalExtrinsic;
+exports.getParachainCollatorsInfo = getParachainCollatorsInfo;
+exports.getTuringCancelCompoundingExtrinsic = getTuringCancelCompoundingExtrinsic;
+exports.getTuringCompoundExtrinsic = getTuringCompoundExtrinsic;
+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");
+var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils3 = 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
+
+async function getParaChainStakingMetadata(chain, substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  const _round = (await chainApi.api.query.parachainStaking.round()).toHuman();
+  const round = (0, _utils3.parseRawNumber)(_round.current);
+  const maxDelegations = chainApi.api.consts.parachainStaking.maxDelegationsPerDelegator.toString();
+  const unstakingDelay = chainApi.api.consts.parachainStaking.delegationBondLessDelay.toString();
+  let _unvestedAllocation;
+  if (chainApi.api.query.vesting && chainApi.api.query.vesting.totalUnvestedAllocation) {
+    _unvestedAllocation = await chainApi.api.query.vesting.totalUnvestedAllocation();
+  }
+  const [_totalStake, _totalIssuance, _inflation] = await Promise.all([chainApi.api.query.parachainStaking.staked(round), chainApi.api.query.balances.totalIssuance(), chainApi.api.query.parachainStaking.inflationConfig()]);
+  let unvestedAllocation;
+  if (_unvestedAllocation) {
+    const rawUnvestedAllocation = _unvestedAllocation.toString();
+    unvestedAllocation = new _util.BN(rawUnvestedAllocation);
+  }
+  const totalStake = _totalStake ? new _util.BN(_totalStake.toString()) : _util.BN_ZERO;
+  const totalIssuance = new _util.BN(_totalIssuance.toString());
+  if (unvestedAllocation) {
+    totalIssuance.add(unvestedAllocation); // for Turing network, read more at https://hackmd.io/@sbAqOuXkRvyiZPOB3Ryn6Q/Sypr3ZJh5
+  }
+
+  const inflationConfig = _inflation.toHuman();
+  const inflation = (0, _utils.getParaCurrentInflation)((0, _utils3.parseRawNumber)(totalStake.toString()), inflationConfig);
+  const unstakingPeriod = parseInt(unstakingDelay) * _constants._STAKING_ERA_LENGTH_MAP[chain];
+  return {
+    chain,
+    type: _KoniTypes.StakingType.NOMINATED,
+    era: round,
+    inflation,
+    minStake: '0',
+    maxValidatorPerNominator: parseInt(maxDelegations),
+    maxWithdrawalRequestPerValidator: 1,
+    // by default
+    allowCancelUnstaking: true,
+    unstakingPeriod
+  };
+}
+async function getParaChainNominatorMetadata(chainInfo, address, substrateApi) {
+  if ((0, _utils2._isChainEvmCompatible)(chainInfo) && !(0, _utilCrypto.isEthereumAddress)(address)) {
+    return;
+  }
+  const chain = chainInfo.slug;
+  const chainApi = await substrateApi.isReady;
+  const nominationList = [];
+  const unstakingMap = {};
+  const _delegatorState = await chainApi.api.query.parachainStaking.delegatorState(address);
+  const delegatorState = _delegatorState.toPrimitive();
+  if (!delegatorState) {
+    return;
+  }
+  let bnTotalActiveStake = _util.BN_ZERO;
+  await Promise.all(delegatorState.delegations.map(async delegation => {
+    const [_delegationScheduledRequests, _identity, _roundInfo] = await Promise.all([chainApi.api.query.parachainStaking.delegationScheduledRequests(delegation.owner), chainApi.api.query.identity.identityOf(delegation.owner), chainApi.api.query.parachainStaking.round()]);
+    const identityInfo = _identity.toHuman();
+    const roundInfo = _roundInfo.toPrimitive();
+    const delegationScheduledRequests = _delegationScheduledRequests.toPrimitive();
+    const currentRound = roundInfo.current;
+    const identity = (0, _utils.parseIdentity)(identityInfo);
+    let hasUnstaking = false;
+
+    // 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[chain];
+          const claimable = Object.values(scheduledRequest.action)[0];
+          unstakingMap[delegation.owner] = {
+            chain,
+            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);
+    bnTotalActiveStake = bnTotalActiveStake.add(bnActiveStake);
+    nominationList.push({
+      chain,
+      validatorAddress: delegation.owner,
+      validatorIdentity: identity,
+      activeStake: bnActiveStake.toString(),
+      hasUnstaking
+    });
+  }));
+  await Promise.all(nominationList.map(async nomination => {
+    const _collatorInfo = await chainApi.api.query.parachainStaking.candidateInfo(nomination.validatorAddress);
+    const collatorInfo = _collatorInfo.toPrimitive();
+    nomination.validatorMinStake = collatorInfo.lowestTopDelegationAmount.toString();
+  }));
+  return {
+    chain,
+    type: _KoniTypes.StakingType.NOMINATED,
+    address: address,
+    activeStake: bnTotalActiveStake.toString(),
+    nominations: nominationList,
+    unstakings: Object.values(unstakingMap)
+  };
+}
+async function getParachainCollatorsInfo(chain, substrateApi) {
+  const apiProps = await substrateApi.isReady;
+  const allValidators = [];
+  const [_allCollators, _collatorCommission] = await Promise.all([apiProps.api.query.parachainStaking.candidateInfo.entries(), apiProps.api.query.parachainStaking.collatorCommission()]);
+  const maxDelegationPerCollator = apiProps.api.consts.parachainStaking.maxTopDelegationsPerCandidate.toString();
+  const rawCollatorCommission = _collatorCommission.toHuman();
+  const collatorCommission = parseFloat(rawCollatorCommission.split('%')[0]);
+  for (const collator of _allCollators) {
+    const collatorAddress = collator[0].toPrimitive();
+    const collatorInfo = collator[1].toPrimitive();
+    allValidators.push({
+      commission: 0,
+      expectedReturn: 0,
+      address: collatorAddress,
+      totalStake: collatorInfo.totalCounted.toString(),
+      ownStake: collatorInfo.bond.toString(),
+      otherStake: (collatorInfo.totalCounted - collatorInfo.bond).toString(),
+      nominatorCount: collatorInfo.delegationCount,
+      blocked: false,
+      isVerified: false,
+      minBond: collatorInfo.lowestTopDelegationAmount.toString(),
+      chain,
+      isCrowded: parseInt(maxDelegationPerCollator) > 0
+    });
+  }
+  const extraInfoMap = {};
+  await Promise.all(allValidators.map(async validator => {
+    var _apiProps$api$query, _apiProps$api$query$i;
+    const [_info, _identity] = await Promise.all([apiProps.api.query.parachainStaking.candidateInfo(validator.address), (_apiProps$api$query = apiProps.api.query) === null || _apiProps$api$query === void 0 ? void 0 : (_apiProps$api$query$i = _apiProps$api$query.identity) === null || _apiProps$api$query$i === void 0 ? void 0 : _apiProps$api$query$i.identityOf(validator.address) // some chains might not have identity pallet
+    ]);
+    const rawInfo = _info.toHuman();
+    const rawIdentity = _identity ? _identity.toHuman() : null;
+    const rawBond = rawInfo === null || rawInfo === void 0 ? void 0 : rawInfo.bond;
+    const bond = new _util.BN(rawBond.replaceAll(',', ''));
+    const delegationCount = (0, _utils3.parseRawNumber)(rawInfo === null || rawInfo === void 0 ? void 0 : rawInfo.delegationCount);
+    const minDelegation = (0, _utils3.parseRawNumber)(rawInfo === null || rawInfo === void 0 ? void 0 : rawInfo.lowestTopDelegationAmount);
+    const active = (rawInfo === null || rawInfo === void 0 ? void 0 : rawInfo.status) === 'Active';
+    let isReasonable = false;
+    let identity;
+    if (rawIdentity !== null) {
+      // Check if identity is eth address
+      isReasonable = rawIdentity.judgements.length > 0;
+      identity = (0, _utils.parseIdentity)(rawIdentity);
+    }
+    extraInfoMap[validator.address] = {
+      identity,
+      isVerified: isReasonable,
+      bond: bond.toString(),
+      minDelegation: minDelegation.toString(),
+      delegationCount,
+      active
+    };
+  }));
+  for (const validator of allValidators) {
+    validator.minBond = extraInfoMap[validator.address].minDelegation.toString();
+    validator.ownStake = extraInfoMap[validator.address].bond.toString();
+    validator.blocked = !extraInfoMap[validator.address].active;
+    validator.identity = extraInfoMap[validator.address].identity;
+    validator.isVerified = extraInfoMap[validator.address].isVerified;
+    // @ts-ignore
+    validator.otherStake = (validator.totalStake - validator.ownStake).toString();
+    validator.nominatorCount = extraInfoMap[validator.address].delegationCount;
+    validator.commission = collatorCommission;
+  }
+  return allValidators;
+}
+async function getParaBondingExtrinsic(nominatorMetadata, chainInfo, substrateApi, amount, selectedCollatorInfo) {
+  const apiPromise = await substrateApi.isReady;
+  const binaryAmount = new _util.BN(amount);
+  const {
+    bondedValidators,
+    nominationCount
+  } = (0, _utils.getBondedValidators)(nominatorMetadata.nominations);
+  if (!bondedValidators.includes((0, _utils3.reformatAddress)(selectedCollatorInfo.address, 0))) {
+    return apiPromise.api.tx.parachainStaking.delegate(selectedCollatorInfo.address, binaryAmount, new _util.BN(selectedCollatorInfo.nominatorCount), nominationCount);
+  } else {
+    return apiPromise.api.tx.parachainStaking.delegatorBondMore(selectedCollatorInfo.address, binaryAmount);
+  }
+}
+async function getParaUnbondingExtrinsic(substrateApi, amount, nominatorMetadata, selectedValidator) {
+  const apiPromise = await substrateApi.isReady;
+  const binaryAmount = new _util.BN(amount);
+  const unstakeAll = (0, _utils.isUnstakeAll)(selectedValidator, nominatorMetadata.nominations, amount);
+  if (!unstakeAll) {
+    return apiPromise.api.tx.parachainStaking.scheduleDelegatorBondLess(selectedValidator, binaryAmount);
+  } else {
+    return apiPromise.api.tx.parachainStaking.scheduleRevokeDelegation(selectedValidator);
+  }
+}
+async function getParaWithdrawalExtrinsic(substrateApi, address, collatorAddress) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.parachainStaking.executeDelegationRequest(address, collatorAddress);
+}
+async function getTuringCompoundExtrinsic(substrateApi, address, collatorAddress, accountMinimum, bondedAmount) {
+  const apiPromise = await substrateApi.isReady;
+
+  // @ts-ignore
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+  const _optimalCompounding = await apiPromise.api.rpc.automationTime.calculateOptimalAutostaking(bondedAmount, collatorAddress);
+
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+  const optimalCompounding = _optimalCompounding.toHuman();
+  const compoundingPeriod = parseInt(optimalCompounding.period); // in days
+
+  const frequency = compoundingPeriod * 24 * 60 * 60; // in seconds
+  const timestamp = new Date();
+  timestamp.setDate(timestamp.getDate() + compoundingPeriod);
+  timestamp.setHours(timestamp.getHours() + Math.round(timestamp.getMinutes() / 60));
+  timestamp.setMinutes(0, 0, 0);
+  const startTime = Math.floor(timestamp.valueOf() / 1000); // must be in seconds
+
+  return apiPromise.api.tx.automationTime.scheduleAutoCompoundDelegatedStakeTask(startTime.toString(), frequency.toString(), collatorAddress, accountMinimum);
+}
+async function getTuringCancelCompoundingExtrinsic(substrateApi, taskId) {
+  const apiPromise = await substrateApi.isReady;
+  return apiPromise.api.tx.automationTime.cancelTask(taskId);
+}
+async function getParaCancelWithdrawalExtrinsic(substrateApi, selectedUnstaking) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.parachainStaking.cancelDelegationRequest(selectedUnstaking.validatorAddress);
+}

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

@@ -0,0 +1,350 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getPoolingBondingExtrinsic = getPoolingBondingExtrinsic;
+exports.getPoolingClaimRewardExtrinsic = getPoolingClaimRewardExtrinsic;
+exports.getPoolingUnbondingExtrinsic = getPoolingUnbondingExtrinsic;
+exports.getPoolingWithdrawalExtrinsic = getPoolingWithdrawalExtrinsic;
+exports.getRelayBondingExtrinsic = getRelayBondingExtrinsic;
+exports.getRelayCancelWithdrawalExtrinsic = getRelayCancelWithdrawalExtrinsic;
+exports.getRelayChainNominatorMetadata = getRelayChainNominatorMetadata;
+exports.getRelayChainPoolMemberMetadata = getRelayChainPoolMemberMetadata;
+exports.getRelayChainStakingMetadata = getRelayChainStakingMetadata;
+exports.getRelayPoolsInfo = getRelayPoolsInfo;
+exports.getRelayUnbondingExtrinsic = getRelayUnbondingExtrinsic;
+exports.getRelayValidatorsInfo = getRelayValidatorsInfo;
+exports.getRelayWithdrawalExtrinsic = getRelayWithdrawalExtrinsic;
+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");
+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
+
+async function getRelayChainStakingMetadata(chain, substrateApi) {
+  var _chainApi$api$query$a, _chainApi$api$query, _chainApi$api$query$n;
+  const chainApi = await substrateApi.isReady;
+  const _era = await chainApi.api.query.staking.currentEra();
+  const currentEra = _era.toString();
+  const maxNominations = chainApi.api.consts.staking.maxNominations.toString();
+  const maxUnlockingChunks = chainApi.api.consts.staking.maxUnlockingChunks.toString();
+  const unlockingEras = chainApi.api.consts.staking.bondingDuration.toString();
+  const [_totalEraStake, _totalIssuance, _auctionCounter, _minimumActiveStake, _minPoolJoin] = await Promise.all([chainApi.api.query.staking.erasTotalStake(parseInt(currentEra)), chainApi.api.query.balances.totalIssuance(), (_chainApi$api$query$a = chainApi.api.query.auctions) === null || _chainApi$api$query$a === void 0 ? void 0 : _chainApi$api$query$a.auctionCounter(), chainApi.api.query.staking.minimumActiveStake(), (_chainApi$api$query = chainApi.api.query) === null || _chainApi$api$query === void 0 ? void 0 : (_chainApi$api$query$n = _chainApi$api$query.nominationPools) === null || _chainApi$api$query$n === void 0 ? void 0 : _chainApi$api$query$n.minJoinBond()]);
+  const minStake = _minimumActiveStake.toString();
+  const minPoolJoin = (_minPoolJoin === null || _minPoolJoin === void 0 ? void 0 : _minPoolJoin.toString()) || undefined;
+  const rawTotalEraStake = _totalEraStake.toString();
+  const rawTotalIssuance = _totalIssuance.toString();
+  const numAuctions = _auctionCounter ? _auctionCounter.toHuman() : 0;
+  const bnTotalEraStake = new _util.BN(rawTotalEraStake);
+  const bnTotalIssuance = new _util.BN(rawTotalIssuance);
+  const inflation = (0, _utils.calculateInflation)(bnTotalEraStake, bnTotalIssuance, numAuctions, chain);
+  const expectedReturn = (0, _utils.calculateChainStakedReturn)(inflation, bnTotalEraStake, bnTotalIssuance, chain);
+  const unlockingPeriod = parseInt(unlockingEras) * _constants._STAKING_ERA_LENGTH_MAP[chain]; // in hours
+
+  return {
+    chain,
+    type: _KoniTypes.StakingType.NOMINATED,
+    era: parseInt(currentEra),
+    expectedReturn,
+    // in %, annually
+    inflation,
+    minStake,
+    maxValidatorPerNominator: parseInt(maxNominations),
+    maxWithdrawalRequestPerValidator: parseInt(maxUnlockingChunks),
+    allowCancelUnstaking: true,
+    unstakingPeriod: unlockingPeriod,
+    minJoinNominationPool: minPoolJoin
+  };
+}
+async function getRelayChainNominatorMetadata(chainInfo, address, substrateApi) {
+  if ((0, _utilCrypto.isEthereumAddress)(address)) {
+    return;
+  }
+  const chain = chainInfo.slug;
+  const chainApi = await substrateApi.isReady;
+  const [_ledger, _nominations, _currentEra, _bonded] = await Promise.all([chainApi.api.query.staking.ledger(address), chainApi.api.query.staking.nominators(address), chainApi.api.query.staking.currentEra(), chainApi.api.query.staking.bonded(address)]);
+  const ledger = _ledger.toJSON();
+  const nominations = _nominations.toJSON();
+  const currentEra = _currentEra.toString();
+  const bonded = _bonded.toHuman();
+  if (!ledger) {
+    return;
+  }
+  const activeStake = ledger.active.toString();
+  const nominationList = [];
+  const unstakingList = [];
+  if (nominations) {
+    const validatorList = nominations.targets;
+    await Promise.all(validatorList.map(async validatorAddress => {
+      const identityInfo = (await chainApi.api.query.identity.identityOf(validatorAddress)).toHuman();
+      const identity = (0, _utils.parseIdentity)(identityInfo);
+      nominationList.push({
+        chain,
+        validatorAddress,
+        validatorIdentity: identity,
+        activeStake: '0' // relaychain allocates stake accordingly
+      });
+    }));
+  }
+
+  ledger.unlocking.forEach(unlockingChunk => {
+    const isClaimable = unlockingChunk.era - parseInt(currentEra) <= 0;
+    const remainingEra = unlockingChunk.era - (parseInt(currentEra) + 1);
+    const waitingTime = remainingEra * _constants._STAKING_ERA_LENGTH_MAP[chain];
+    unstakingList.push({
+      chain,
+      status: isClaimable ? _KoniTypes.UnstakingStatus.CLAIMABLE : _KoniTypes.UnstakingStatus.UNLOCKING,
+      claimable: unlockingChunk.value.toString(),
+      waitingTime: waitingTime > 0 ? waitingTime : 0
+    });
+  });
+  return {
+    chain,
+    type: _KoniTypes.StakingType.NOMINATED,
+    address: address,
+    activeStake,
+    nominations: nominationList,
+    unstakings: unstakingList,
+    isBondedBefore: bonded !== null
+  };
+}
+async function getRelayChainPoolMemberMetadata(chainInfo, address, substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  const [_poolMemberInfo, _currentEra] = await Promise.all([chainApi.api.query.nominationPools.poolMembers(address), chainApi.api.query.staking.currentEra()]);
+  const poolMemberInfo = _poolMemberInfo.toPrimitive();
+  const currentEra = _currentEra.toString();
+  if (!poolMemberInfo) {
+    return;
+  }
+  const _poolMetadata = await chainApi.api.query.nominationPools.metadata(poolMemberInfo.poolId);
+  const poolMetadata = _poolMetadata.toPrimitive();
+  const poolName = (0, _utils.transformPoolName)(poolMetadata.isUtf8 ? poolMetadata.toUtf8() : poolMetadata.toString());
+  const joinedPoolInfo = {
+    activeStake: poolMemberInfo.points.toString(),
+    chain: chainInfo.slug,
+    validatorIdentity: poolName,
+    validatorAddress: poolMemberInfo.poolId.toString(),
+    // use poolId
+    hasUnstaking: poolMemberInfo.unbondingEras && Object.keys(poolMemberInfo.unbondingEras).length > 0
+  };
+  const unstakings = [];
+  Object.entries(poolMemberInfo.unbondingEras).forEach(_ref => {
+    let [unlockingEra, amount] = _ref;
+    const isClaimable = parseInt(unlockingEra) - parseInt(currentEra) <= 0;
+    const remainingEra = parseInt(unlockingEra) - (parseInt(currentEra) + 1);
+    const waitingTime = remainingEra * _constants._STAKING_ERA_LENGTH_MAP[chainInfo.slug];
+    unstakings.push({
+      chain: chainInfo.slug,
+      status: isClaimable ? _KoniTypes.UnstakingStatus.CLAIMABLE : _KoniTypes.UnstakingStatus.UNLOCKING,
+      claimable: amount.toString(),
+      waitingTime: waitingTime > 0 ? waitingTime : 0
+    });
+  });
+  return {
+    chain: chainInfo.slug,
+    type: _KoniTypes.StakingType.POOLED,
+    address,
+    activeStake: poolMemberInfo.points.toString(),
+    nominations: [joinedPoolInfo],
+    // can only join 1 pool at a time
+    unstakings
+  };
+}
+async function getRelayValidatorsInfo(chain, substrateApi, decimals, chainStakingMetadata) {
+  const chainApi = await substrateApi.isReady;
+  const _era = await chainApi.api.query.staking.currentEra();
+  const currentEra = _era.toString();
+  const allValidators = [];
+  const validatorInfoList = [];
+  const [_totalEraStake, _eraStakers, _minBond] = await Promise.all([chainApi.api.query.staking.erasTotalStake(parseInt(currentEra)), chainApi.api.query.staking.erasStakers.entries(parseInt(currentEra)), chainApi.api.query.staking.minNominatorBond()]);
+  const maxNominatorRewarded = chainApi.api.consts.staking.maxNominatorRewardedPerValidator.toString();
+  const bnTotalEraStake = new _util.BN(_totalEraStake.toString());
+  const eraStakers = _eraStakers;
+  const rawMinBond = _minBond.toHuman();
+  const minBond = rawMinBond.replaceAll(',', '');
+  const totalStakeMap = {};
+  const bnDecimals = new _util.BN((10 ** decimals).toString());
+  for (const item of eraStakers) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    const rawValidatorInfo = item[0].toHuman();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
+    const rawValidatorStat = item[1].toHuman();
+    const validatorAddress = rawValidatorInfo[1];
+    const rawTotalStake = rawValidatorStat.total;
+    const rawOwnStake = rawValidatorStat.own;
+    const bnTotalStake = new _util.BN(rawTotalStake.replaceAll(',', ''));
+    const bnOwnStake = new _util.BN(rawOwnStake.replaceAll(',', ''));
+    const otherStake = bnTotalStake.sub(bnOwnStake);
+    totalStakeMap[validatorAddress] = bnTotalStake;
+    let nominatorCount = 0;
+    if ('others' in rawValidatorStat) {
+      const others = rawValidatorStat.others;
+      nominatorCount = others.length;
+    }
+    allValidators.push(validatorAddress);
+    validatorInfoList.push({
+      address: validatorAddress,
+      totalStake: bnTotalStake.toString(),
+      ownStake: bnOwnStake.toString(),
+      otherStake: otherStake.toString(),
+      nominatorCount,
+      // to be added later
+      commission: 0,
+      expectedReturn: 0,
+      blocked: false,
+      isVerified: false,
+      minBond,
+      isCrowded: nominatorCount > parseInt(maxNominatorRewarded)
+    });
+  }
+  const extraInfoMap = {};
+  await Promise.all(allValidators.map(async address => {
+    var _chainApi$api$query2, _chainApi$api$query2$, _identityInfo$judgeme;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const [_commissionInfo, _identityInfo] = await Promise.all([chainApi.api.query.staking.validators(address), (_chainApi$api$query2 = chainApi.api.query) === null || _chainApi$api$query2 === void 0 ? void 0 : (_chainApi$api$query2$ = _chainApi$api$query2.identity) === null || _chainApi$api$query2$ === void 0 ? void 0 : _chainApi$api$query2$.identityOf(address)]);
+    const commissionInfo = _commissionInfo.toHuman();
+    const identityInfo = _identityInfo ? _identityInfo.toHuman() : null;
+    let identity;
+    if (identityInfo !== null) {
+      identity = (0, _utils.parseIdentity)(identityInfo);
+    }
+    extraInfoMap[address] = {
+      commission: commissionInfo.commission,
+      blocked: commissionInfo.blocked,
+      identity,
+      isVerified: identityInfo && (identityInfo === null || identityInfo === void 0 ? void 0 : (_identityInfo$judgeme = identityInfo.judgements) === null || _identityInfo$judgeme === void 0 ? void 0 : _identityInfo$judgeme.length) > 0
+    };
+  }));
+  const bnAvgStake = bnTotalEraStake.divn(validatorInfoList.length).div(bnDecimals);
+  for (const validator of validatorInfoList) {
+    const commission = extraInfoMap[validator.address].commission;
+    const bnValidatorStake = totalStakeMap[validator.address].div(bnDecimals);
+    validator.expectedReturn = _constants._STAKING_CHAIN_GROUP.aleph.includes(chain) ? (0, _utils.calculateAlephZeroValidatorReturn)(chainStakingMetadata.expectedReturn, (0, _utils.getCommission)(commission)) : (0, _utils.calculateValidatorStakedReturn)(chainStakingMetadata.expectedReturn, bnValidatorStake, bnAvgStake, (0, _utils.getCommission)(commission));
+    validator.commission = parseFloat(commission.split('%')[0]);
+    validator.blocked = extraInfoMap[validator.address].blocked;
+    validator.identity = extraInfoMap[validator.address].identity;
+    validator.isVerified = extraInfoMap[validator.address].isVerified;
+  }
+  return validatorInfoList;
+}
+async function getRelayPoolsInfo(chain, substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  const nominationPools = [];
+  const _allPoolsInfo = await chainApi.api.query.nominationPools.reversePoolIdLookup.entries();
+  await Promise.all(_allPoolsInfo.map(async _poolInfo => {
+    var _bondedPool$points;
+    const poolAddressList = _poolInfo[0].toHuman();
+    const poolAddress = poolAddressList[0];
+    const poolId = _poolInfo[1].toPrimitive();
+    const [_bondedPool, _metadata] = await Promise.all([chainApi.api.query.nominationPools.bondedPools(poolId), chainApi.api.query.nominationPools.metadata(poolId)]);
+    const poolMetadata = _metadata.toPrimitive();
+    const bondedPool = _bondedPool.toPrimitive();
+    const poolName = (0, _utils.transformPoolName)(poolMetadata.isUtf8 ? poolMetadata.toUtf8() : poolMetadata.toString());
+    nominationPools.push({
+      id: poolId,
+      address: poolAddress,
+      name: poolName,
+      bondedAmount: ((_bondedPool$points = bondedPool.points) === null || _bondedPool$points === void 0 ? void 0 : _bondedPool$points.toString()) || '0',
+      roles: bondedPool.roles,
+      memberCounter: bondedPool.memberCounter,
+      state: bondedPool.state
+    });
+  }));
+  return nominationPools;
+}
+async function getRelayBondingExtrinsic(substrateApi, amount, targetValidators, nominatorMetadata, chainInfo) {
+  let bondDest = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 'Staked';
+  const chainApi = await substrateApi.isReady;
+  const binaryAmount = new _util.BN(amount);
+  let bondTx;
+  let nominateTx;
+  if (!nominatorMetadata.isBondedBefore) {
+    // first time
+    bondTx = chainApi.api.tx.staking.bond(nominatorMetadata.address, binaryAmount, bondDest);
+    nominateTx = chainApi.api.tx.staking.nominate(targetValidators);
+    return chainApi.api.tx.utility.batchAll([bondTx, nominateTx]);
+  } else {
+    if (binaryAmount.gt(_util.BN_ZERO)) {
+      bondTx = chainApi.api.tx.staking.bondExtra(binaryAmount);
+    }
+    if (nominatorMetadata.isBondedBefore && targetValidators.length > 0) {
+      nominateTx = chainApi.api.tx.staking.nominate(targetValidators);
+    }
+  }
+  if (bondTx && !nominateTx) {
+    return bondTx;
+  } else if (nominateTx && !bondTx) {
+    return nominateTx;
+  }
+  return chainApi.api.tx.utility.batchAll([bondTx, nominateTx]);
+}
+async function getRelayUnbondingExtrinsic(substrateApi, amount, nominatorMetadata) {
+  const chainApi = await substrateApi.isReady;
+  const binaryAmount = new _util.BN(amount);
+  const isUnstakeAll = amount === nominatorMetadata.activeStake;
+  if (isUnstakeAll) {
+    const chillTx = chainApi.api.tx.staking.chill();
+    const unbondTx = chainApi.api.tx.staking.unbond(binaryAmount);
+    return chainApi.api.tx.utility.batchAll([chillTx, unbondTx]);
+  }
+  return chainApi.api.tx.staking.unbond(binaryAmount);
+}
+async function getRelayWithdrawalExtrinsic(substrateApi, address) {
+  const chainApi = await substrateApi.isReady;
+  if (chainApi.api.tx.staking.withdrawUnbonded.meta.args.length === 1) {
+    const _slashingSpans = (await chainApi.api.query.staking.slashingSpans(address)).toHuman();
+    const slashingSpanCount = _slashingSpans !== null ? _slashingSpans.spanIndex : '0';
+    return chainApi.api.tx.staking.withdrawUnbonded(slashingSpanCount);
+  } else {
+    return chainApi.api.tx.staking.withdrawUnbonded();
+  }
+}
+async function getRelayCancelWithdrawalExtrinsic(substrateApi, selectedUnstaking) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.staking.rebond(selectedUnstaking.claimable);
+}
+
+// Pooling txs
+
+async function getPoolingClaimRewardExtrinsic(substrateApi) {
+  let bondReward = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  const chainApi = await substrateApi.isReady;
+  if (bondReward) {
+    return chainApi.api.tx.nominationPools.bondExtra('Rewards');
+  }
+  return chainApi.api.tx.nominationPools.claimPayout();
+}
+async function getPoolingBondingExtrinsic(substrateApi, amount, selectedPoolId, nominatorMetadata) {
+  const chainApi = await substrateApi.isReady;
+  const bnActiveStake = new _util.BN((nominatorMetadata === null || nominatorMetadata === void 0 ? void 0 : nominatorMetadata.activeStake) || '0');
+  if (bnActiveStake.gt(_util.BN_ZERO)) {
+    // already joined a pool
+    return chainApi.api.tx.nominationPools.bondExtra({
+      FreeBalance: amount
+    });
+  }
+  return chainApi.api.tx.nominationPools.join(amount, selectedPoolId);
+}
+async function getPoolingUnbondingExtrinsic(substrateApi, amount, nominatorMetadata) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.nominationPools.unbond({
+    Id: nominatorMetadata.address
+  }, amount);
+}
+async function getPoolingWithdrawalExtrinsic(substrateApi, nominatorMetadata) {
+  const chainApi = await substrateApi.isReady;
+  if (chainApi.api.tx.nominationPools.withdrawUnbonded.meta.args.length === 2) {
+    const _slashingSpans = (await chainApi.api.query.staking.slashingSpans(nominatorMetadata.address)).toHuman();
+    const slashingSpanCount = _slashingSpans !== null ? _slashingSpans.spanIndex : '0';
+    return chainApi.api.tx.nominationPools.withdrawUnbonded({
+      Id: nominatorMetadata.address
+    }, slashingSpanCount);
+  } else {
+    return chainApi.api.tx.nominationPools.withdrawUnbonded({
+      Id: nominatorMetadata.address
+    });
+  }
+}