@subwallet/extension-base 0.8.3-2 → 1.0.1

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

@@ -0,0 +1,458 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getAstarBondingExtrinsic = getAstarBondingExtrinsic;
+exports.getAstarBondingTxInfo = getAstarBondingTxInfo;
+exports.getAstarClaimRewardExtrinsic = getAstarClaimRewardExtrinsic;
+exports.getAstarClaimRewardTxInfo = getAstarClaimRewardTxInfo;
+exports.getAstarDappsInfo = getAstarDappsInfo;
+exports.getAstarNominatorMetadata = getAstarNominatorMetadata;
+exports.getAstarStakingMetadata = getAstarStakingMetadata;
+exports.getAstarUnbondingExtrinsic = getAstarUnbondingExtrinsic;
+exports.getAstarUnbondingTxInfo = getAstarUnbondingTxInfo;
+exports.getAstarWithdrawalExtrinsic = getAstarWithdrawalExtrinsic;
+exports.getAstarWithdrawalTxInfo = getAstarWithdrawalTxInfo;
+exports.handleAstarBondingTxInfo = handleAstarBondingTxInfo;
+exports.handleAstarClaimRewardTxInfo = handleAstarClaimRewardTxInfo;
+exports.handleAstarUnbondingTxInfo = handleAstarUnbondingTxInfo;
+exports.handleAstarUnlockingInfo = handleAstarUnlockingInfo;
+exports.handleAstarWithdrawalTxInfo = handleAstarWithdrawalTxInfo;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _balance = require("@subwallet/extension-base/koni/api/dotsama/balance");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _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({
+          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
+  };
+}
+async function getAstarDappsInfo(networkKey, substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  const rawMaxStakerPerContract = chainApi.api.consts.dappsStaking.maxNumberOfStakersPerContract.toHuman();
+  const allDappsInfo = [];
+  const maxStakerPerContract = (0, _utils2.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, _utils2.parseRawNumber)(_era.toHuman());
+  const allDapps = _allDapps;
+  await Promise.all(allDapps.map(async dapp => {
+    const dappName = dapp.name;
+    const dappAddress = dapp.address;
+    const dappIcon = (0, _utils2.isUrl)(dapp.iconUrl) ? dapp.iconUrl : undefined;
+    const _contractInfo = await chainApi.api.query.dappsStaking.contractEraStake({
+      Evm: dappAddress
+    }, era);
+    const contractInfo = _contractInfo.toHuman();
+    let totalStake = 0;
+    let stakerCount = 0;
+    if (contractInfo !== null) {
+      totalStake = (0, _utils2.parseRawNumber)(contractInfo.total);
+      stakerCount = (0, _utils2.parseRawNumber)(contractInfo.numberOfStakers);
+    }
+    allDappsInfo.push({
+      commission: 0,
+      expectedReturn: 0,
+      address: dappAddress,
+      totalStake: totalStake.toString(),
+      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 getAstarBondingTxInfo(chainInfo, substrateApi, stakerAddress, amount, dappInfo) {
+  const apiPromise = await substrateApi.isReady;
+  const {
+    decimals
+  } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+  const parsedAmount = amount * 10 ** decimals;
+  const binaryAmount = new _util.BN(parsedAmount.toString());
+  const extrinsic = apiPromise.api.tx.dappsStaking.bondAndStake({
+    Evm: dappInfo.address
+  }, binaryAmount);
+  return extrinsic.paymentInfo(stakerAddress);
+}
+async function handleAstarBondingTxInfo(chainInfo, amount, networkKey, stakerAddress, dappInfo, substrateApiMap, evmApiMap) {
+  const {
+    decimals,
+    symbol
+  } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+  try {
+    const [txInfo, balance] = await Promise.all([getAstarBondingTxInfo(chainInfo, substrateApiMap[networkKey], stakerAddress, amount, dappInfo), (0, _balance.getFreeBalance)(networkKey, stakerAddress, substrateApiMap, evmApiMap)]);
+    const feeString = (0, _utils2.parseNumberToDisplay)(txInfo.partialFee, decimals) + ` ${symbol}`;
+    const rawFee = (0, _utils2.parseRawNumber)(txInfo.partialFee.toString());
+    const binaryBalance = new _util.BN(balance);
+    const sumAmount = txInfo.partialFee.addn(amount);
+    const balanceError = sumAmount.gt(binaryBalance);
+    return {
+      rawFee,
+      fee: feeString,
+      balanceError
+    };
+  } catch (e) {
+    return {
+      fee: `0.0000 ${symbol}`,
+      balanceError: false
+    };
+  }
+}
+async function getAstarBondingExtrinsic(substrateApi, amount, dappInfo) {
+  const chainApi = await substrateApi.isReady;
+  const binaryAmount = new _util.BN(amount);
+  return chainApi.api.tx.dappsStaking.bondAndStake({
+    Evm: dappInfo.address
+  }, binaryAmount);
+}
+async function getAstarUnbondingTxInfo(chainInfo, substrateApi, stakerAddress, amount, dappAddress) {
+  const apiPromise = await substrateApi.isReady;
+  const {
+    decimals
+  } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+  const parsedAmount = amount * 10 ** decimals;
+  const binaryAmount = new _util.BN(parsedAmount.toString());
+  const extrinsic = apiPromise.api.tx.dappsStaking.unbondAndUnstake({
+    Evm: dappAddress
+  }, binaryAmount);
+  return extrinsic.paymentInfo(stakerAddress);
+}
+async function handleAstarUnbondingTxInfo(chainInfo, amount, networkKey, stakerAddress, dappAddress, substrateApiMap, evmApiMap) {
+  const {
+    decimals,
+    symbol
+  } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+  try {
+    const [txInfo, balance] = await Promise.all([getAstarUnbondingTxInfo(chainInfo, substrateApiMap[networkKey], stakerAddress, amount, dappAddress), (0, _balance.getFreeBalance)(networkKey, stakerAddress, substrateApiMap, evmApiMap)]);
+    const feeString = (0, _utils2.parseNumberToDisplay)(txInfo.partialFee, decimals) + ` ${symbol}`;
+    const rawFee = (0, _utils2.parseRawNumber)(txInfo.partialFee.toString());
+    const binaryBalance = new _util.BN(balance);
+    const balanceError = txInfo.partialFee.gt(binaryBalance);
+    return {
+      rawFee,
+      fee: feeString,
+      balanceError
+    };
+  } catch (e) {
+    return {
+      fee: `0.0000 ${symbol}`,
+      balanceError: false
+    };
+  }
+}
+async function getAstarUnbondingExtrinsic(substrateApi, amount, dappAddress) {
+  const apiPromise = await substrateApi.isReady;
+  const binaryAmount = new _util.BN(amount);
+  return apiPromise.api.tx.dappsStaking.unbondAndUnstake({
+    Evm: dappAddress
+  }, binaryAmount);
+}
+async function getAstarUnlockingInfo(substrateApi, address, networkKey) {
+  const chainApi = await substrateApi.isReady;
+  const [_stakingInfo, _era] = await Promise.all([chainApi.api.query.dappsStaking.ledger(address), chainApi.api.query.dappsStaking.currentEra()]);
+  const currentEra = (0, _utils2.parseRawNumber)(_era.toHuman());
+  const stakingInfo = _stakingInfo.toHuman();
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  const unlockingChunks = stakingInfo.unbondingInfo.unlockingChunks;
+  let nextWithdrawalEra = -1;
+  let nextWithdrawalAmount = 0;
+  let redeemable = 0;
+  for (const chunk of unlockingChunks) {
+    const unlockEra = (0, _utils2.parseRawNumber)(chunk.unlockEra);
+    const amount = (0, _utils2.parseRawNumber)(chunk.amount);
+
+    // Find next withdrawal
+    if (nextWithdrawalEra === -1) {
+      nextWithdrawalEra = unlockEra;
+      nextWithdrawalAmount = amount;
+    } else if (unlockEra <= nextWithdrawalEra) {
+      nextWithdrawalEra = unlockEra;
+      nextWithdrawalAmount += amount;
+    }
+
+    // Find redeemable
+    if (unlockEra - currentEra <= 0) {
+      redeemable += amount;
+    }
+  }
+  const nextWithdrawal = (nextWithdrawalEra - currentEra) * _constants._STAKING_ERA_LENGTH_MAP[networkKey];
+  return {
+    nextWithdrawal,
+    nextWithdrawalAmount,
+    redeemable
+  };
+}
+async function handleAstarUnlockingInfo(substrateApi, chainInfo, networkKey, address, type) {
+  const {
+    nextWithdrawal,
+    nextWithdrawalAmount,
+    redeemable
+  } = await getAstarUnlockingInfo(substrateApi, address, networkKey);
+  const {
+    decimals
+  } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+  const parsedRedeemable = redeemable / 10 ** decimals;
+  const parsedNextWithdrawalAmount = nextWithdrawalAmount / 10 ** decimals;
+  return {
+    address,
+    type,
+    chain: networkKey,
+    nextWithdrawal: nextWithdrawal,
+    redeemable: parsedRedeemable,
+    nextWithdrawalAmount: parsedNextWithdrawalAmount
+  };
+}
+async function getAstarWithdrawalTxInfo(substrateApi, address) {
+  const apiPromise = await substrateApi.isReady;
+  const extrinsic = apiPromise.api.tx.dappsStaking.withdrawUnbonded();
+  return extrinsic.paymentInfo(address);
+}
+async function handleAstarWithdrawalTxInfo(networkKey, chainInfo, substrateApiMap, evmApiMap, address) {
+  const [txInfo, balance] = await Promise.all([getAstarWithdrawalTxInfo(substrateApiMap[networkKey], address), (0, _balance.getFreeBalance)(networkKey, address, substrateApiMap, evmApiMap)]);
+  const {
+    decimals,
+    symbol
+  } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+  const feeString = (0, _utils2.parseNumberToDisplay)(txInfo.partialFee, decimals) + ` ${symbol}`;
+  const rawFee = (0, _utils2.parseRawNumber)(txInfo.partialFee.toString());
+  const binaryBalance = new _util.BN(balance);
+  const balanceError = txInfo.partialFee.gt(binaryBalance);
+  return {
+    rawFee,
+    fee: feeString,
+    balanceError
+  };
+}
+async function getAstarWithdrawalExtrinsic(substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.dappsStaking.withdrawUnbonded();
+}
+async function getAstarClaimRewardTxInfo(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, _utils2.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;
+    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, _utils2.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, _utils2.parseRawNumber)(nextEraData.era);
+      const isLastEra = i === stakes.length - 1;
+      const eraToClaim = isLastEra ? currentEra - parsedEra : nextEra - parsedEra;
+      numberOfUnclaimedEra += eraToClaim;
+    }
+    for (let i = 0; i < numberOfUnclaimedEra; i++) {
+      const tx = apiPromise.api.tx.dappsStaking.claimStaker({
+        Evm: dappAddress
+      });
+      transactions.push(tx);
+    }
+  }
+  console.log('no of tx: ', transactions.length);
+  const extrinsic = apiPromise.api.tx.utility.batch(transactions);
+  return extrinsic.paymentInfo(address);
+}
+async function handleAstarClaimRewardTxInfo(address, networkKey, chainInfo, substrateApiMap, evmApiMap) {
+  const {
+    decimals,
+    symbol
+  } = (0, _utils._getChainNativeTokenBasicInfo)(chainInfo);
+  try {
+    const [txInfo, balance] = await Promise.all([getAstarClaimRewardTxInfo(substrateApiMap[networkKey], address), (0, _balance.getFreeBalance)(networkKey, address, substrateApiMap, evmApiMap)]);
+    const feeString = (0, _utils2.parseNumberToDisplay)(txInfo.partialFee, decimals) + ` ${symbol}`;
+    const rawFee = (0, _utils2.parseRawNumber)(txInfo.partialFee.toString());
+    const binaryBalance = new _util.BN(balance);
+    const balanceError = txInfo.partialFee.gt(binaryBalance);
+    return {
+      rawFee,
+      fee: feeString,
+      balanceError
+    };
+  } catch (e) {
+    return {
+      fee: `0.0000 ${symbol}`,
+      balanceError: false
+    };
+  }
+}
+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, _utils2.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 _stakes2;
+      const {
+        era,
+        staked
+      } = stakes[i];
+      const bnStaked = new _util.BN(staked.replaceAll(',', ''));
+      const parsedEra = (0, _utils2.parseRawNumber)(era);
+      if (bnStaked.eq(new _util.BN(0))) {
+        continue;
+      }
+      const nextEraData = (_stakes2 = stakes[i + 1]) !== null && _stakes2 !== void 0 ? _stakes2 : null;
+      const nextEra = nextEraData && (0, _utils2.parseRawNumber)(nextEraData.era);
+      const isLastEra = i === stakes.length - 1;
+      const eraToClaim = isLastEra ? currentEra - parsedEra : nextEra - parsedEra;
+      numberOfUnclaimedEra += eraToClaim;
+    }
+    for (let i = 0; i < Math.min(numberOfUnclaimedEra, maxTx); i++) {
+      const tx = apiPromise.api.tx.dappsStaking.claimStaker({
+        Evm: dappAddress
+      });
+      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, nominatorMetadata, selectedValidators, substrateApi) {
+  if (_constants._STAKING_CHAIN_GROUP.para.includes(chainInfo.slug)) {
+    return (0, _paraChain.getParaBondingExtrinsic)(nominatorMetadata, chainInfo, substrateApi, amount, selectedValidators[0]); // 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)(nominatorMetadata, substrateApi, amount, selectedValidators[0]);
+  }
+  return (0, _relayChain.getRelayBondingExtrinsic)(substrateApi, amount, selectedValidators, nominatorMetadata, chainInfo);
+}
+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);
+}