@subwallet/extension-base 0.8.4-0 → 1.0.2-1

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

@@ -0,0 +1,384 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { StakingStatus, StakingType, UnstakingStatus } from '@subwallet/extension-base/background/KoniTypes';
+import { calculateAlephZeroValidatorReturn, calculateChainStakedReturn, calculateInflation, calculateValidatorStakedReturn, getCommission, parseIdentity, parsePoolStashAddress, transformPoolName } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import { _STAKING_CHAIN_GROUP, _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
+import { reformatAddress } from '@subwallet/extension-base/utils';
+import { BN, BN_ZERO } from '@polkadot/util';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export 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 BN(rawTotalEraStake);
+  const bnTotalIssuance = new BN(rawTotalIssuance);
+  const inflation = calculateInflation(bnTotalEraStake, bnTotalIssuance, numAuctions, chain);
+  const expectedReturn = calculateChainStakedReturn(inflation, bnTotalEraStake, bnTotalIssuance, chain);
+  const unlockingPeriod = parseInt(unlockingEras) * _STAKING_ERA_LENGTH_MAP[chain]; // in hours
+
+  return {
+    chain,
+    type: StakingType.NOMINATED,
+    era: parseInt(currentEra),
+    expectedReturn,
+    // in %, annually
+    inflation,
+    minStake,
+    maxValidatorPerNominator: parseInt(maxNominations),
+    maxWithdrawalRequestPerValidator: parseInt(maxUnlockingChunks),
+    allowCancelUnstaking: true,
+    unstakingPeriod: unlockingPeriod,
+    minJoinNominationPool: minPoolJoin
+  };
+}
+export async function getRelayChainNominatorMetadata(chainInfo, address, substrateApi) {
+  if (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 _maxNominatorRewardedPerValidator = chainApi.api.consts.staking.maxNominatorRewardedPerValidator.toString();
+  const maxNominatorRewardedPerValidator = parseInt(_maxNominatorRewardedPerValidator);
+  const ledger = _ledger.toPrimitive();
+  const nominations = _nominations.toPrimitive();
+  const currentEra = _currentEra.toString();
+  const bonded = _bonded.toHuman();
+  if (!ledger) {
+    return;
+  }
+  let stakingStatus = StakingStatus.NOT_EARNING;
+  const activeStake = ledger.active.toString();
+  const nominationList = [];
+  const unstakingList = [];
+  if (nominations) {
+    const validatorList = nominations.targets;
+    await Promise.all(validatorList.map(async validatorAddress => {
+      let nominationStatus = StakingStatus.NOT_EARNING;
+      const [_identityInfo, _eraStaker] = await Promise.all([chainApi.api.query.identity.identityOf(validatorAddress), chainApi.api.query.staking.erasStakers(currentEra, validatorAddress)]);
+      const eraStaker = _eraStaker.toPrimitive();
+      const identityInfo = _identityInfo.toHuman();
+      const identity = parseIdentity(identityInfo);
+      const topNominators = eraStaker.others.map(nominator => {
+        return nominator.who;
+      });
+      if (topNominators.slice(0, maxNominatorRewardedPerValidator).includes(reformatAddress(address, _getChainSubstrateAddressPrefix(chainInfo)))) {
+        // if address in top nominators
+        nominationStatus = StakingStatus.EARNING_REWARD;
+      }
+      nominationList.push({
+        chain,
+        validatorAddress,
+        status: nominationStatus,
+        validatorIdentity: identity,
+        activeStake: '0' // relaychain allocates stake accordingly
+      });
+    }));
+  }
+
+  for (const nomination of nominationList) {
+    if (nomination.status === StakingStatus.EARNING_REWARD) {
+      // only need 1 earning nomination to count
+      stakingStatus = StakingStatus.EARNING_REWARD;
+      break;
+    }
+  }
+  ledger.unlocking.forEach(unlockingChunk => {
+    const isClaimable = unlockingChunk.era - parseInt(currentEra) <= 0;
+    const remainingEra = unlockingChunk.era - (parseInt(currentEra) + 1);
+    const waitingTime = remainingEra * _STAKING_ERA_LENGTH_MAP[chain];
+    unstakingList.push({
+      chain,
+      status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
+      claimable: unlockingChunk.value.toString(),
+      waitingTime: waitingTime > 0 ? waitingTime : 0
+    });
+  });
+  return {
+    chain,
+    type: StakingType.NOMINATED,
+    status: stakingStatus,
+    address: address,
+    activeStake,
+    nominations: nominationList,
+    unstakings: unstakingList,
+    isBondedBefore: bonded !== null
+  };
+}
+export 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 _maxNominatorRewardedPerValidator = chainApi.api.consts.staking.maxNominatorRewardedPerValidator.toString();
+  const maxNominatorRewardedPerValidator = parseInt(_maxNominatorRewardedPerValidator);
+  const poolsPalletId = chainApi.api.consts.nominationPools.palletId.toString();
+  const poolMemberInfo = _poolMemberInfo.toPrimitive();
+  const currentEra = _currentEra.toString();
+  if (!poolMemberInfo) {
+    return;
+  }
+  let stakingStatus = StakingStatus.NOT_EARNING;
+  const _poolMetadata = await chainApi.api.query.nominationPools.metadata(poolMemberInfo.poolId);
+  const poolMetadata = _poolMetadata.toPrimitive();
+  const poolName = transformPoolName(poolMetadata.isUtf8 ? poolMetadata.toUtf8() : poolMetadata.toString());
+  const poolStashAccount = parsePoolStashAddress(chainApi.api, 0, poolMemberInfo.poolId, poolsPalletId);
+  const _nominations = await chainApi.api.query.staking.nominators(poolStashAccount);
+  const nominations = _nominations.toJSON();
+  if (nominations) {
+    const validatorList = nominations.targets;
+    await Promise.all(validatorList.map(async validatorAddress => {
+      const _eraStaker = await chainApi.api.query.staking.erasStakers(currentEra, validatorAddress);
+      const eraStaker = _eraStaker.toPrimitive();
+      const topNominators = eraStaker.others.map(nominator => {
+        return nominator.who;
+      }).slice(0, maxNominatorRewardedPerValidator);
+      if (topNominators.includes(reformatAddress(poolStashAccount, _getChainSubstrateAddressPrefix(chainInfo)))) {
+        // if address in top nominators
+        stakingStatus = StakingStatus.EARNING_REWARD;
+      }
+    }));
+  }
+  const joinedPoolInfo = {
+    activeStake: poolMemberInfo.points.toString(),
+    chain: chainInfo.slug,
+    status: stakingStatus,
+    validatorIdentity: poolName,
+    validatorAddress: poolMemberInfo.poolId.toString(),
+    // use poolId
+    hasUnstaking: poolMemberInfo.unbondingEras && Object.keys(poolMemberInfo.unbondingEras).length > 0
+  };
+  const unstakings = [];
+  Object.entries(poolMemberInfo.unbondingEras).forEach(([unlockingEra, amount]) => {
+    const isClaimable = parseInt(unlockingEra) - parseInt(currentEra) <= 0;
+    const remainingEra = parseInt(unlockingEra) - (parseInt(currentEra) + 1);
+    const waitingTime = remainingEra * _STAKING_ERA_LENGTH_MAP[chainInfo.slug];
+    unstakings.push({
+      chain: chainInfo.slug,
+      status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
+      claimable: amount.toString(),
+      waitingTime: waitingTime > 0 ? waitingTime : 0
+    });
+  });
+  return {
+    chain: chainInfo.slug,
+    type: StakingType.POOLED,
+    address,
+    status: stakingStatus,
+    activeStake: poolMemberInfo.points.toString(),
+    nominations: [joinedPoolInfo],
+    // can only join 1 pool at a time
+    unstakings
+  };
+}
+export 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 BN(_totalEraStake.toString());
+  const eraStakers = _eraStakers;
+  const rawMinBond = _minBond.toHuman();
+  const minBond = rawMinBond.replaceAll(',', '');
+  const totalStakeMap = {};
+  const bnDecimals = new 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 BN(rawTotalStake.replaceAll(',', ''));
+    const bnOwnStake = new 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 = 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 = _STAKING_CHAIN_GROUP.aleph.includes(chain) ? calculateAlephZeroValidatorReturn(chainStakingMetadata.expectedReturn, getCommission(commission)) : calculateValidatorStakedReturn(chainStakingMetadata.expectedReturn, bnValidatorStake, bnAvgStake, 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;
+}
+export 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 = 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;
+}
+export async function getRelayBondingExtrinsic(substrateApi, amount, targetValidators, chainInfo, address, nominatorMetadata, bondDest = 'Staked') {
+  const chainApi = await substrateApi.isReady;
+  const binaryAmount = new BN(amount);
+  let bondTx;
+  let nominateTx;
+  const validatorParamList = targetValidators.map(validator => {
+    return validator.address;
+  });
+  if (!nominatorMetadata) {
+    bondTx = chainApi.api.tx.staking.bond(address, binaryAmount, bondDest);
+    nominateTx = chainApi.api.tx.staking.nominate(validatorParamList);
+    return chainApi.api.tx.utility.batchAll([bondTx, nominateTx]);
+  }
+  if (!nominatorMetadata.isBondedBefore) {
+    // first time
+    bondTx = chainApi.api.tx.staking.bond(nominatorMetadata.address, binaryAmount, bondDest);
+    nominateTx = chainApi.api.tx.staking.nominate(validatorParamList);
+    return chainApi.api.tx.utility.batchAll([bondTx, nominateTx]);
+  } else {
+    if (binaryAmount.gt(BN_ZERO)) {
+      bondTx = chainApi.api.tx.staking.bondExtra(binaryAmount);
+    }
+    if (nominatorMetadata.isBondedBefore && targetValidators.length > 0) {
+      nominateTx = chainApi.api.tx.staking.nominate(validatorParamList);
+    }
+  }
+  if (bondTx && !nominateTx) {
+    return bondTx;
+  } else if (nominateTx && !bondTx) {
+    return nominateTx;
+  }
+  return chainApi.api.tx.utility.batchAll([bondTx, nominateTx]);
+}
+export async function getRelayUnbondingExtrinsic(substrateApi, amount, nominatorMetadata) {
+  const chainApi = await substrateApi.isReady;
+  const binaryAmount = new 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);
+}
+export 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();
+  }
+}
+export async function getRelayCancelWithdrawalExtrinsic(substrateApi, selectedUnstaking) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.staking.rebond(selectedUnstaking.claimable);
+}
+
+// Pooling txs
+
+export async function getPoolingClaimRewardExtrinsic(substrateApi, bondReward = true) {
+  const chainApi = await substrateApi.isReady;
+  if (bondReward) {
+    return chainApi.api.tx.nominationPools.bondExtra('Rewards');
+  }
+  return chainApi.api.tx.nominationPools.claimPayout();
+}
+export async function getPoolingBondingExtrinsic(substrateApi, amount, selectedPoolId, nominatorMetadata) {
+  const chainApi = await substrateApi.isReady;
+  const bnActiveStake = new BN((nominatorMetadata === null || nominatorMetadata === void 0 ? void 0 : nominatorMetadata.activeStake) || '0');
+  if (bnActiveStake.gt(BN_ZERO)) {
+    // already joined a pool
+    return chainApi.api.tx.nominationPools.bondExtra({
+      FreeBalance: amount
+    });
+  }
+  return chainApi.api.tx.nominationPools.join(amount, selectedPoolId);
+}
+export async function getPoolingUnbondingExtrinsic(substrateApi, amount, nominatorMetadata) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.nominationPools.unbond({
+    Id: nominatorMetadata.address
+  }, amount);
+}
+export 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
+    });
+  }
+}

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

@@ -0,0 +1,154 @@
+/// <reference types="bn.js" />
+import { NominationInfo, NominatorMetadata, StakingType, UnstakingInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { _SubstrateInflationParams } from '@subwallet/extension-base/services/chain-service/constants';
+import { ApiPromise } from '@polkadot/api';
+import { BN } from '@polkadot/util';
+export interface PalletNominationPoolsPoolMember {
+    poolId: number;
+    points: number;
+    lasRecordedRewardCounter: number;
+    unbondingEras: Record<string, number>;
+}
+export interface PalletDappsStakingDappInfo {
+    address: string;
+    name: string;
+    gitHubUrl: string;
+    tags: string[];
+    url: string;
+    imagesUrl: string[];
+}
+export interface PalletDappsStakingUnlockingChunk {
+    amount: number;
+    unlockEra: number;
+}
+export interface PalletDappsStakingAccountLedger {
+    locked: number;
+    unbondingInfo: {
+        unlockingChunks: PalletDappsStakingUnlockingChunk[];
+    };
+}
+export interface BlockHeader {
+    parentHash: string;
+    number: number;
+    stateRoot: string;
+    extrinsicsRoot: string;
+}
+export interface ParachainStakingStakeOption {
+    owner: string;
+    amount: number;
+}
+export interface ParachainStakingCandidateMetadata {
+    bond: number;
+    delegationCount: number;
+    totalCounted: number;
+    lowestTopDelegationAmount: number;
+    status: any | 'Active';
+}
+export declare enum PalletParachainStakingRequestType {
+    REVOKE = "revoke",
+    DECREASE = "decrease",
+    BOND_LESS = "bondLess"
+}
+export interface PalletParachainStakingDelegationRequestsScheduledRequest {
+    delegator: string;
+    whenExecutable: number;
+    action: Record<PalletParachainStakingRequestType, number>;
+}
+export interface PalletParachainStakingDelegationInfo {
+    owner: string;
+    amount: number;
+}
+export interface PalletParachainStakingDelegator {
+    id: string;
+    delegations: PalletParachainStakingDelegationInfo[];
+    total: number;
+    lessTotal: number;
+    status: number;
+}
+export interface PalletStakingExposureItem {
+    who: string;
+    value: number;
+}
+export interface PalletStakingExposure {
+    total: number;
+    own: number;
+    others: PalletStakingExposureItem[];
+}
+export interface PalletIdentityRegistration {
+    judgements: any[];
+    deposit: number;
+    info: {
+        display: {
+            Raw: string;
+        };
+        web: {
+            Raw: string;
+        };
+        twitter: {
+            Raw: string;
+        };
+        riot: {
+            Raw: string;
+        };
+    };
+}
+export interface ValidatorExtraInfo {
+    commission: string;
+    blocked: false;
+    identity?: string;
+    isVerified: boolean;
+}
+export interface Unlocking {
+    remainingEras: BN;
+    value: BN;
+}
+export declare function parsePoolStashAddress(api: ApiPromise, index: number, poolId: number, poolsPalletId: string): string;
+export declare function transformPoolName(input: string): string;
+export declare function parseIdentity(identityInfo: PalletIdentityRegistration | null): string | undefined;
+export declare function getInflationParams(networkKey: string): _SubstrateInflationParams;
+export declare function calcInflationUniformEraPayout(totalIssuance: BN, yearlyInflationInTokens: number): number;
+export declare function calcInflationRewardCurve(minInflation: number, stakedFraction: number, idealStake: number, idealInterest: number, falloff: number): number;
+export declare function calculateInflation(totalEraStake: BN, totalIssuance: BN, numAuctions: number, networkKey: string): number;
+export declare function calculateChainStakedReturn(inflation: number, totalEraStake: BN, totalIssuance: BN, networkKey: string): number;
+export declare function calculateAlephZeroValidatorReturn(chainStakedReturn: number, commission: number): number;
+export declare function calculateValidatorStakedReturn(chainStakedReturn: number, totalValidatorStake: BN, avgStake: BN, commission: number): number;
+export declare function getCommission(commissionString: string): number;
+export interface InflationConfig {
+    expect: {
+        min: string;
+        ideal: string;
+        max: string;
+    };
+    annual: {
+        min: string;
+        ideal: string;
+        max: string;
+    };
+    round: {
+        min: string;
+        ideal: string;
+        max: string;
+    };
+}
+export declare function getParaCurrentInflation(totalStaked: number, inflationConfig: InflationConfig): number;
+export interface TuringOptimalCompoundFormat {
+    period: string;
+    apy: string;
+}
+export declare function isShowNominationByValidator(chain: string): 'showByValue' | 'showByValidator' | 'mixed';
+export declare function getBondedValidators(nominations: NominationInfo[]): {
+    nominationCount: number;
+    bondedValidators: string[];
+};
+export declare function isUnstakeAll(selectedValidator: string, nominations: NominationInfo[], unstakeAmount: string): boolean;
+export declare enum StakingAction {
+    STAKE = "STAKE",
+    UNSTAKE = "UNSTAKE",
+    WITHDRAW = "WITHDRAW",
+    CLAIM_REWARD = "CLAIM_REWARD",
+    CANCEL_UNSTAKE = "CANCEL_UNSTAKE"
+}
+export declare function getStakingAvailableActionsByChain(chain: string, type: StakingType): StakingAction[];
+export declare function getStakingAvailableActionsByNominator(nominatorMetadata: NominatorMetadata): StakingAction[];
+export declare function isActionFromValidator(stakingType: StakingType, chain: string): boolean;
+export declare function getWithdrawalInfo(nominatorMetadata: NominatorMetadata): UnstakingInfo | undefined;