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

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

@@ -0,0 +1,255 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAstarBondingExtrinsic = getAstarBondingExtrinsic;
+exports.getAstarClaimRewardExtrinsic = getAstarClaimRewardExtrinsic;
+exports.getAstarDappsInfo = getAstarDappsInfo;
+exports.getAstarNominatorMetadata = getAstarNominatorMetadata;
+exports.getAstarStakingMetadata = getAstarStakingMetadata;
+exports.getAstarUnbondingExtrinsic = getAstarUnbondingExtrinsic;
+exports.getAstarWithdrawalExtrinsic = getAstarWithdrawalExtrinsic;
+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 _crossFetch = _interopRequireDefault(require("cross-fetch"));
+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 getAstarStakingMetadata(chain, substrateApi) {
+  const aprPromise = new Promise(function (resolve) {
+    (0, _crossFetch.default)(`https://api.astar.network/api/v1/${chain}/dapps-staking/apr`, {
+      method: 'GET'
+    }).then(resp => {
+      resolve(resp.json());
+    }).catch(console.error);
+  });
+  const timeout = new Promise(resolve => {
+    const id = setTimeout(() => {
+      clearTimeout(id);
+      resolve(null);
+    }, 8000);
+  });
+  const aprRacePromise = Promise.race([timeout, aprPromise]); // need race because API often timeout
+
+  const [aprInfo, chainApi] = await Promise.all([aprRacePromise, substrateApi.isReady]);
+  const era = (await chainApi.api.query.dappsStaking.currentEra()).toString();
+  const minDelegatorStake = chainApi.api.consts.dappsStaking.minimumStakingAmount.toString();
+  const unstakingDelay = chainApi.api.consts.dappsStaking.unbondingPeriod.toString();
+  const unstakingPeriod = parseInt(unstakingDelay) * _constants._STAKING_ERA_LENGTH_MAP[chain];
+  return {
+    chain,
+    type: _KoniTypes.StakingType.NOMINATED,
+    expectedReturn: aprInfo !== null ? aprInfo : undefined,
+    era: parseInt(era),
+    minStake: minDelegatorStake,
+    maxValidatorPerNominator: 100,
+    // temporary fix for Astar, there's no limit for now
+    maxWithdrawalRequestPerValidator: 1,
+    // by default
+    allowCancelUnstaking: true,
+    unstakingPeriod
+  };
+}
+async function getAstarNominatorMetadata(chainInfo, address, substrateApi) {
+  if ((0, _utilCrypto.isEthereumAddress)(address)) {
+    return;
+  }
+  const chain = chainInfo.slug;
+  const chainApi = await substrateApi.isReady;
+  const nominationList = [];
+  const unstakingList = [];
+  const allDappsReq = new Promise(function (resolve) {
+    (0, _crossFetch.default)(`https://api.astar.network/api/v1/${chain}/dapps-staking/dapps`, {
+      method: 'GET'
+    }).then(resp => {
+      resolve(resp.json());
+    }).catch(console.error);
+  });
+  const [_ledger, _era, _stakerInfo] = await Promise.all([chainApi.api.query.dappsStaking.ledger(address), chainApi.api.query.dappsStaking.currentEra(), chainApi.api.query.dappsStaking.generalStakerInfo.entries(address)]);
+  const ledger = _ledger.toPrimitive();
+  const currentEra = _era.toString();
+  let bnTotalActiveStake = _util.BN_ZERO;
+  if (_stakerInfo.length > 0) {
+    const dAppInfoMap = {};
+    const allDapps = await allDappsReq;
+    allDapps.forEach(dappInfo => {
+      dAppInfoMap[dappInfo.address.toLowerCase()] = dappInfo;
+    });
+    for (const item of _stakerInfo) {
+      const data = item[0].toHuman();
+      const stakedDapp = data[1];
+      const stakeData = item[1].toPrimitive();
+      const stakeList = stakeData.stakes;
+      const dappAddress = stakedDapp.Evm.toLowerCase();
+      const currentStake = stakeList.slice(-1)[0].staked.toString() || '0';
+      const bnCurrentStake = new _util.BN(currentStake);
+      if (bnCurrentStake.gt(_util.BN_ZERO)) {
+        bnTotalActiveStake = bnTotalActiveStake.add(bnCurrentStake);
+        const dappInfo = dAppInfoMap[dappAddress];
+        nominationList.push({
+          status: _KoniTypes.StakingStatus.NOT_EARNING,
+          // TODO
+          chain,
+          validatorAddress: dappAddress,
+          activeStake: currentStake,
+          validatorMinStake: '0',
+          validatorIdentity: dappInfo === null || dappInfo === void 0 ? void 0 : dappInfo.name,
+          hasUnstaking: false // cannot get unstaking info by dapp
+        });
+      }
+    }
+  }
+
+  const unlockingChunks = ledger.unbondingInfo.unlockingChunks;
+  if (unlockingChunks.length > 0) {
+    const nearestUnstaking = unlockingChunks[0]; // only handle 1 unstaking request at a time, might need to change
+
+    const isClaimable = nearestUnstaking.unlockEra - parseInt(currentEra) <= 0;
+    const remainingEra = nearestUnstaking.unlockEra - (parseInt(currentEra) + 1);
+    const waitingTime = remainingEra * _constants._STAKING_ERA_LENGTH_MAP[chain];
+    unstakingList.push({
+      chain,
+      status: isClaimable ? _KoniTypes.UnstakingStatus.CLAIMABLE : _KoniTypes.UnstakingStatus.UNLOCKING,
+      claimable: nearestUnstaking.amount.toString(),
+      waitingTime: waitingTime > 0 ? waitingTime : 0
+    });
+  }
+  if (nominationList.length === 0 && unstakingList.length === 0) {
+    return;
+  }
+  return {
+    chain,
+    type: _KoniTypes.StakingType.NOMINATED,
+    address: address,
+    activeStake: bnTotalActiveStake.toString(),
+    nominations: nominationList,
+    unstakings: unstakingList,
+    status: _KoniTypes.StakingStatus.NOT_EARNING // TODO
+  };
+}
+
+async function getAstarDappsInfo(networkKey, substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  const rawMaxStakerPerContract = chainApi.api.consts.dappsStaking.maxNumberOfStakersPerContract.toHuman();
+  const allDappsInfo = [];
+  const maxStakerPerContract = (0, _utils.parseRawNumber)(rawMaxStakerPerContract);
+  const allDappsReq = new Promise(function (resolve) {
+    (0, _crossFetch.default)(`https://api.astar.network/api/v1/${networkKey}/dapps-staking/dapps`, {
+      method: 'GET'
+    }).then(resp => {
+      resolve(resp.json());
+    }).catch(console.error);
+  });
+  const [_era, _allDapps] = await Promise.all([chainApi.api.query.dappsStaking.currentEra(), allDappsReq]);
+  const era = (0, _utils.parseRawNumber)(_era.toHuman());
+  const allDapps = _allDapps;
+  await Promise.all(allDapps.map(async dapp => {
+    const dappName = dapp.name;
+    const dappAddress = dapp.address;
+    const dappIcon = (0, _utils.isUrl)(dapp.iconUrl) ? dapp.iconUrl : undefined;
+    const contractParam = (0, _utilCrypto.isEthereumAddress)(dappAddress) ? {
+      Evm: dappAddress
+    } : {
+      Wasm: dappAddress
+    };
+    const _contractInfo = await chainApi.api.query.dappsStaking.contractEraStake(contractParam, era);
+    const contractInfo = _contractInfo.toPrimitive();
+    let totalStake = '0';
+    let stakerCount = 0;
+    if (contractInfo !== null) {
+      var _contractInfo$total;
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+      totalStake = contractInfo === null || contractInfo === void 0 ? void 0 : (_contractInfo$total = contractInfo.total) === null || _contractInfo$total === void 0 ? void 0 : _contractInfo$total.toString();
+      stakerCount = contractInfo.numberOfStakers;
+    }
+    allDappsInfo.push({
+      commission: 0,
+      expectedReturn: 0,
+      address: dappAddress,
+      totalStake: totalStake,
+      ownStake: '0',
+      otherStake: totalStake.toString(),
+      nominatorCount: stakerCount,
+      blocked: false,
+      isVerified: false,
+      minBond: '0',
+      icon: dappIcon,
+      identity: dappName,
+      chain: networkKey,
+      isCrowded: stakerCount >= maxStakerPerContract
+    });
+  }));
+  return allDappsInfo;
+}
+async function getAstarBondingExtrinsic(substrateApi, amount, dappInfo) {
+  const chainApi = await substrateApi.isReady;
+  const binaryAmount = new _util.BN(amount);
+  const dappParam = (0, _utilCrypto.isEthereumAddress)(dappInfo.address) ? {
+    Evm: dappInfo.address
+  } : {
+    Wasm: dappInfo.address
+  };
+  return chainApi.api.tx.dappsStaking.bondAndStake(dappParam, binaryAmount);
+}
+async function getAstarUnbondingExtrinsic(substrateApi, amount, dappAddress) {
+  const apiPromise = await substrateApi.isReady;
+  const binaryAmount = new _util.BN(amount);
+  const dappParam = (0, _utilCrypto.isEthereumAddress)(dappAddress) ? {
+    Evm: dappAddress
+  } : {
+    Wasm: dappAddress
+  };
+  return apiPromise.api.tx.dappsStaking.unbondAndUnstake(dappParam, binaryAmount);
+}
+async function getAstarWithdrawalExtrinsic(substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.dappsStaking.withdrawUnbonded();
+}
+async function getAstarClaimRewardExtrinsic(substrateApi, address) {
+  const apiPromise = await substrateApi.isReady;
+  const [_stakedDapps, _currentEra] = await Promise.all([apiPromise.api.query.dappsStaking.generalStakerInfo.entries(address), apiPromise.api.query.dappsStaking.currentEra()]);
+  const currentEra = (0, _utils.parseRawNumber)(_currentEra.toHuman());
+  const transactions = [];
+  for (const item of _stakedDapps) {
+    const data = item[0].toHuman();
+    const stakedDapp = data[1];
+    const stakeData = item[1].toHuman();
+    const stakes = stakeData.stakes;
+    const dappAddress = stakedDapp.Evm.toLowerCase();
+    let numberOfUnclaimedEra = 0;
+    const maxTx = 50;
+    for (let i = 0; i < stakes.length; i++) {
+      var _stakes;
+      const {
+        era,
+        staked
+      } = stakes[i];
+      const bnStaked = new _util.BN(staked.replaceAll(',', ''));
+      const parsedEra = (0, _utils.parseRawNumber)(era);
+      if (bnStaked.eq(new _util.BN(0))) {
+        continue;
+      }
+      const nextEraData = (_stakes = stakes[i + 1]) !== null && _stakes !== void 0 ? _stakes : null;
+      const nextEra = nextEraData && (0, _utils.parseRawNumber)(nextEraData.era);
+      const isLastEra = i === stakes.length - 1;
+      const eraToClaim = isLastEra ? currentEra - parsedEra : nextEra - parsedEra;
+      numberOfUnclaimedEra += eraToClaim;
+    }
+    const dappParam = (0, _utilCrypto.isEthereumAddress)(dappAddress) ? {
+      Evm: dappAddress
+    } : {
+      Wasm: dappAddress
+    };
+    for (let i = 0; i < Math.min(numberOfUnclaimedEra, maxTx); i++) {
+      const tx = apiPromise.api.tx.dappsStaking.claimStaker(dappParam);
+      transactions.push(tx);
+    }
+  }
+  console.log('no of astar claim reward tx: ', transactions.length);
+  return apiPromise.api.tx.utility.batch(transactions);
+}

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

@@ -0,0 +1,108 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBondingExtrinsic = getBondingExtrinsic;
+exports.getCancelWithdrawalExtrinsic = getCancelWithdrawalExtrinsic;
+exports.getChainStakingMetadata = getChainStakingMetadata;
+exports.getClaimRewardExtrinsic = getClaimRewardExtrinsic;
+exports.getNominationPoolsInfo = getNominationPoolsInfo;
+exports.getNominatorMetadata = getNominatorMetadata;
+exports.getUnbondingExtrinsic = getUnbondingExtrinsic;
+exports.getValidatorsInfo = getValidatorsInfo;
+exports.getWithdrawalExtrinsic = getWithdrawalExtrinsic;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _amplitude = require("@subwallet/extension-base/koni/api/staking/bonding/amplitude");
+var _astar = require("@subwallet/extension-base/koni/api/staking/bonding/astar");
+var _paraChain = require("@subwallet/extension-base/koni/api/staking/bonding/paraChain");
+var _relayChain = require("@subwallet/extension-base/koni/api/staking/bonding/relayChain");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// all addresses must be converted to its chain format
+
+async function getChainStakingMetadata(chain, substrateApi) {
+  if (_constants._STAKING_CHAIN_GROUP.astar.includes(chain)) {
+    return (0, _astar.getAstarStakingMetadata)(chain, substrateApi);
+  } else if (_constants._STAKING_CHAIN_GROUP.para.includes(chain)) {
+    return (0, _paraChain.getParaChainStakingMetadata)(chain, substrateApi);
+  } else if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+    return (0, _amplitude.getAmplitudeStakingMetadata)(chain, substrateApi);
+  }
+  return (0, _relayChain.getRelayChainStakingMetadata)(chain, substrateApi);
+}
+async function getNominatorMetadata(chainInfo, address, substrateApi) {
+  if (_constants._STAKING_CHAIN_GROUP.astar.includes(chainInfo.slug)) {
+    return (0, _astar.getAstarNominatorMetadata)(chainInfo, address, substrateApi);
+  } else if (_constants._STAKING_CHAIN_GROUP.para.includes(chainInfo.slug)) {
+    return (0, _paraChain.getParaChainNominatorMetadata)(chainInfo, address, substrateApi);
+  } else if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chainInfo.slug)) {
+    return (0, _amplitude.getAmplitudeNominatorMetadata)(chainInfo, address, substrateApi);
+  }
+  return (0, _relayChain.getRelayChainNominatorMetadata)(chainInfo, address, substrateApi);
+}
+async function getValidatorsInfo(networkKey, substrateApi, decimals, chainStakingMetadata) {
+  if (_constants._STAKING_CHAIN_GROUP.para.includes(networkKey)) {
+    return (0, _paraChain.getParachainCollatorsInfo)(networkKey, substrateApi);
+  } else if (_constants._STAKING_CHAIN_GROUP.astar.includes(networkKey)) {
+    return (0, _astar.getAstarDappsInfo)(networkKey, substrateApi);
+  } else if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(networkKey)) {
+    return (0, _amplitude.getAmplitudeCollatorsInfo)(networkKey, substrateApi);
+  }
+  return (0, _relayChain.getRelayValidatorsInfo)(networkKey, substrateApi, decimals, chainStakingMetadata);
+}
+async function getNominationPoolsInfo(chain, substrateApi) {
+  return (0, _relayChain.getRelayPoolsInfo)(chain, substrateApi);
+}
+async function getBondingExtrinsic(chainInfo, amount, selectedValidators, substrateApi, address, nominatorMetadata) {
+  if (_constants._STAKING_CHAIN_GROUP.para.includes(chainInfo.slug)) {
+    return (0, _paraChain.getParaBondingExtrinsic)(chainInfo, substrateApi, amount, selectedValidators[0], nominatorMetadata); // only select 1 validator at a time
+  } else if (_constants._STAKING_CHAIN_GROUP.astar.includes(chainInfo.slug)) {
+    return (0, _astar.getAstarBondingExtrinsic)(substrateApi, amount, selectedValidators[0]);
+  } else if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chainInfo.slug)) {
+    return (0, _amplitude.getAmplitudeBondingExtrinsic)(substrateApi, amount, selectedValidators[0], nominatorMetadata);
+  }
+  return (0, _relayChain.getRelayBondingExtrinsic)(substrateApi, amount, selectedValidators, chainInfo, address, nominatorMetadata);
+}
+async function getUnbondingExtrinsic(nominatorMetadata, amount, chain, substrateApi, selectedValidator) {
+  if (_constants._STAKING_CHAIN_GROUP.para.includes(chain)) {
+    return (0, _paraChain.getParaUnbondingExtrinsic)(substrateApi, amount, nominatorMetadata, selectedValidator);
+  } else if (_constants._STAKING_CHAIN_GROUP.astar.includes(chain)) {
+    return (0, _astar.getAstarUnbondingExtrinsic)(substrateApi, amount, selectedValidator);
+  } else if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+    return (0, _amplitude.getAmplitudeUnbondingExtrinsic)(substrateApi, amount, nominatorMetadata, selectedValidator);
+  }
+  return (0, _relayChain.getRelayUnbondingExtrinsic)(substrateApi, amount, nominatorMetadata);
+}
+async function getWithdrawalExtrinsic(substrateApi, chain, nominatorMetadata, validatorAddress) {
+  if (nominatorMetadata.type === _KoniTypes.StakingType.POOLED) {
+    return (0, _relayChain.getPoolingWithdrawalExtrinsic)(substrateApi, nominatorMetadata);
+  }
+  if (_constants._STAKING_CHAIN_GROUP.para.includes(chain)) {
+    return (0, _paraChain.getParaWithdrawalExtrinsic)(substrateApi, nominatorMetadata.address, validatorAddress);
+  } else if (_constants._STAKING_CHAIN_GROUP.astar.includes(chain)) {
+    return (0, _astar.getAstarWithdrawalExtrinsic)(substrateApi);
+  } else if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+    return (0, _amplitude.getAmplitudeWithdrawalExtrinsic)(substrateApi, nominatorMetadata.address);
+  }
+  return (0, _relayChain.getRelayWithdrawalExtrinsic)(substrateApi, nominatorMetadata.address);
+}
+async function getClaimRewardExtrinsic(substrateApi, chain, address, stakingType) {
+  let bondReward = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
+  if (stakingType === _KoniTypes.StakingType.POOLED) {
+    return (0, _relayChain.getPoolingClaimRewardExtrinsic)(substrateApi, bondReward);
+  } else if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+    return (0, _amplitude.getAmplitudeClaimRewardExtrinsic)(substrateApi);
+  }
+  return (0, _astar.getAstarClaimRewardExtrinsic)(substrateApi, address);
+}
+async function getCancelWithdrawalExtrinsic(substrateApi, chain, selectedUnstaking) {
+  if (_constants._STAKING_CHAIN_GROUP.para.includes(chain)) {
+    return (0, _paraChain.getParaCancelWithdrawalExtrinsic)(substrateApi, selectedUnstaking);
+  } else if (_constants._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
+    return (0, _amplitude.getAmplitudeCancelWithdrawalExtrinsic)(substrateApi);
+  }
+  return (0, _relayChain.getRelayCancelWithdrawalExtrinsic)(substrateApi, selectedUnstaking);
+}

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

@@ -0,0 +1,260 @@
+"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,
+      status: _KoniTypes.StakingStatus.NOT_EARNING,
+      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 allCollators = [];
+  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].toHuman();
+    const collatorAddress = _collatorAddress[0];
+    const collatorInfo = collator[1].toPrimitive();
+    allCollators.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(allCollators.map(async collator => {
+    var _apiProps$api$query, _apiProps$api$query$i;
+    const [_info, _identity] = await Promise.all([apiProps.api.query.parachainStaking.candidateInfo(collator.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(collator.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[collator.address] = {
+      identity,
+      isVerified: isReasonable,
+      bond: bond.toString(),
+      minDelegation: minDelegation.toString(),
+      delegationCount,
+      active
+    };
+  }));
+  for (const validator of allCollators) {
+    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 allCollators;
+}
+async function getParaBondingExtrinsic(chainInfo, substrateApi, amount, selectedCollatorInfo, nominatorMetadata) {
+  const apiPromise = await substrateApi.isReady;
+  const binaryAmount = new _util.BN(amount);
+  if (!nominatorMetadata) {
+    return apiPromise.api.tx.parachainStaking.delegate(selectedCollatorInfo.address, binaryAmount, new _util.BN(selectedCollatorInfo.nominatorCount), 0);
+  }
+  const {
+    bondedValidators,
+    nominationCount
+  } = (0, _utils.getBondedValidators)(nominatorMetadata.nominations);
+  const parsedSelectedCollatorAddress = (0, _utils3.reformatAddress)(selectedCollatorInfo.address, 0);
+  if (!bondedValidators.includes(parsedSelectedCollatorAddress)) {
+    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);
+}