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

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

@@ -0,0 +1,405 @@
+"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 _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 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 _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 = _KoniTypes.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 = _KoniTypes.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 = (0, _utils.parseIdentity)(identityInfo);
+      const topNominators = eraStaker.others.map(nominator => {
+        return nominator.who;
+      });
+      if (topNominators.slice(0, maxNominatorRewardedPerValidator).includes((0, _utils3.reformatAddress)(address, (0, _utils2._getChainSubstrateAddressPrefix)(chainInfo)))) {
+        // if address in top nominators
+        nominationStatus = _KoniTypes.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 === _KoniTypes.StakingStatus.EARNING_REWARD) {
+      // only need 1 earning nomination to count
+      stakingStatus = _KoniTypes.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 * _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,
+    status: stakingStatus,
+    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 _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 = _KoniTypes.StakingStatus.NOT_EARNING;
+  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 poolStashAccount = (0, _utils.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((0, _utils3.reformatAddress)(poolStashAccount, (0, _utils2._getChainSubstrateAddressPrefix)(chainInfo)))) {
+        // if address in top nominators
+        stakingStatus = _KoniTypes.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(_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,
+    status: stakingStatus,
+    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, chainInfo, address, nominatorMetadata) {
+  let bondDest = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 'Staked';
+  const chainApi = await substrateApi.isReady;
+  const binaryAmount = new _util.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(_util.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]);
+}
+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
+    });
+  }
+}

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

@@ -0,0 +1,248 @@
+"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.getStakingAvailableActionsByChain = getStakingAvailableActionsByChain;
+exports.getStakingAvailableActionsByNominator = getStakingAvailableActionsByNominator;
+exports.getWithdrawalInfo = getWithdrawalInfo;
+exports.isActionFromValidator = isActionFromValidator;
+exports.isShowNominationByValidator = isShowNominationByValidator;
+exports.isUnstakeAll = isUnstakeAll;
+exports.parseIdentity = parseIdentity;
+exports.parsePoolStashAddress = parsePoolStashAddress;
+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 parsePoolStashAddress(api, index, poolId, poolsPalletId) {
+  const ModPrefix = (0, _util.stringToU8a)('modl');
+  const U32Opts = {
+    bitLength: 32,
+    isLe: true
+  };
+  const EmptyH256 = new Uint8Array(32);
+  return api.registry.createType('AccountId32', (0, _util.u8aConcat)(ModPrefix, poolsPalletId, new Uint8Array([index]), (0, _util.bnToU8a)(new _util.BN(poolId.toString()), U32Opts), EmptyH256)).toString();
+}
+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) {
+    const parsedValidatorAddress = (0, _utils.reformatAddress)(nomination.validatorAddress, 0);
+    const parsedSelectedValidator = (0, _utils.reformatAddress)(selectedValidator, 0);
+    if (parsedValidatorAddress === parsedSelectedValidator) {
+      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 getStakingAvailableActionsByChain(chain, type) {
+  if (type === _KoniTypes.StakingType.POOLED) {
+    return [StakingAction.STAKE, StakingAction.UNSTAKE, StakingAction.WITHDRAW, StakingAction.CLAIM_REWARD];
+  }
+  if (_constants._STAKING_CHAIN_GROUP.para.includes(chain)) {
+    return [StakingAction.STAKE, StakingAction.UNSTAKE, StakingAction.WITHDRAW, StakingAction.CANCEL_UNSTAKE];
+  } else if (_constants._STAKING_CHAIN_GROUP.astar.includes(chain)) {
+    return [StakingAction.STAKE, StakingAction.UNSTAKE, StakingAction.WITHDRAW, StakingAction.CLAIM_REWARD];
+  } else if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+    return [StakingAction.STAKE, StakingAction.UNSTAKE, StakingAction.WITHDRAW];
+  }
+  return [StakingAction.STAKE, StakingAction.UNSTAKE, StakingAction.WITHDRAW, StakingAction.CANCEL_UNSTAKE];
+}
+function getStakingAvailableActionsByNominator(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;
+}