@subwallet/extension-base 0.8.4-0 → 1.0.1

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

@@ -0,0 +1,436 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { StakingType, UnstakingStatus } from '@subwallet/extension-base/background/KoniTypes';
+import { getFreeBalance } from '@subwallet/extension-base/koni/api/dotsama/balance';
+import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _getChainNativeTokenBasicInfo } from '@subwallet/extension-base/services/chain-service/utils';
+import { isUrl, parseNumberToDisplay, parseRawNumber } from '@subwallet/extension-base/utils';
+import fetch from 'cross-fetch';
+import { BN, BN_ZERO } from '@polkadot/util';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export async function getAstarStakingMetadata(chain, substrateApi) {
+  const aprPromise = new Promise(function (resolve) {
+    fetch(`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) * _STAKING_ERA_LENGTH_MAP[chain];
+  return {
+    chain,
+    type: 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
+  };
+}
+export async function getAstarNominatorMetadata(chainInfo, address, substrateApi) {
+  if (isEthereumAddress(address)) {
+    return;
+  }
+  const chain = chainInfo.slug;
+  const chainApi = await substrateApi.isReady;
+  const nominationList = [];
+  const unstakingList = [];
+  const allDappsReq = new Promise(function (resolve) {
+    fetch(`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 = 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 BN(currentStake);
+      if (bnCurrentStake.gt(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 * _STAKING_ERA_LENGTH_MAP[chain];
+    unstakingList.push({
+      chain,
+      status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
+      claimable: nearestUnstaking.amount.toString(),
+      waitingTime: waitingTime > 0 ? waitingTime : 0
+    });
+  }
+  if (nominationList.length === 0 && unstakingList.length === 0) {
+    return;
+  }
+  return {
+    chain,
+    type: StakingType.NOMINATED,
+    address: address,
+    activeStake: bnTotalActiveStake.toString(),
+    nominations: nominationList,
+    unstakings: unstakingList
+  };
+}
+export async function getAstarDappsInfo(networkKey, substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  const rawMaxStakerPerContract = chainApi.api.consts.dappsStaking.maxNumberOfStakersPerContract.toHuman();
+  const allDappsInfo = [];
+  const maxStakerPerContract = parseRawNumber(rawMaxStakerPerContract);
+  const allDappsReq = new Promise(function (resolve) {
+    fetch(`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 = parseRawNumber(_era.toHuman());
+  const allDapps = _allDapps;
+  await Promise.all(allDapps.map(async dapp => {
+    const dappName = dapp.name;
+    const dappAddress = dapp.address;
+    const dappIcon = 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 = parseRawNumber(contractInfo.total);
+      stakerCount = 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;
+}
+export async function getAstarBondingTxInfo(chainInfo, substrateApi, stakerAddress, amount, dappInfo) {
+  const apiPromise = await substrateApi.isReady;
+  const {
+    decimals
+  } = _getChainNativeTokenBasicInfo(chainInfo);
+  const parsedAmount = amount * 10 ** decimals;
+  const binaryAmount = new BN(parsedAmount.toString());
+  const extrinsic = apiPromise.api.tx.dappsStaking.bondAndStake({
+    Evm: dappInfo.address
+  }, binaryAmount);
+  return extrinsic.paymentInfo(stakerAddress);
+}
+export async function handleAstarBondingTxInfo(chainInfo, amount, networkKey, stakerAddress, dappInfo, substrateApiMap, evmApiMap) {
+  const {
+    decimals,
+    symbol
+  } = _getChainNativeTokenBasicInfo(chainInfo);
+  try {
+    const [txInfo, balance] = await Promise.all([getAstarBondingTxInfo(chainInfo, substrateApiMap[networkKey], stakerAddress, amount, dappInfo), getFreeBalance(networkKey, stakerAddress, substrateApiMap, evmApiMap)]);
+    const feeString = parseNumberToDisplay(txInfo.partialFee, decimals) + ` ${symbol}`;
+    const rawFee = parseRawNumber(txInfo.partialFee.toString());
+    const binaryBalance = new 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
+    };
+  }
+}
+export async function getAstarBondingExtrinsic(substrateApi, amount, dappInfo) {
+  const chainApi = await substrateApi.isReady;
+  const binaryAmount = new BN(amount);
+  return chainApi.api.tx.dappsStaking.bondAndStake({
+    Evm: dappInfo.address
+  }, binaryAmount);
+}
+export async function getAstarUnbondingTxInfo(chainInfo, substrateApi, stakerAddress, amount, dappAddress) {
+  const apiPromise = await substrateApi.isReady;
+  const {
+    decimals
+  } = _getChainNativeTokenBasicInfo(chainInfo);
+  const parsedAmount = amount * 10 ** decimals;
+  const binaryAmount = new BN(parsedAmount.toString());
+  const extrinsic = apiPromise.api.tx.dappsStaking.unbondAndUnstake({
+    Evm: dappAddress
+  }, binaryAmount);
+  return extrinsic.paymentInfo(stakerAddress);
+}
+export async function handleAstarUnbondingTxInfo(chainInfo, amount, networkKey, stakerAddress, dappAddress, substrateApiMap, evmApiMap) {
+  const {
+    decimals,
+    symbol
+  } = _getChainNativeTokenBasicInfo(chainInfo);
+  try {
+    const [txInfo, balance] = await Promise.all([getAstarUnbondingTxInfo(chainInfo, substrateApiMap[networkKey], stakerAddress, amount, dappAddress), getFreeBalance(networkKey, stakerAddress, substrateApiMap, evmApiMap)]);
+    const feeString = parseNumberToDisplay(txInfo.partialFee, decimals) + ` ${symbol}`;
+    const rawFee = parseRawNumber(txInfo.partialFee.toString());
+    const binaryBalance = new BN(balance);
+    const balanceError = txInfo.partialFee.gt(binaryBalance);
+    return {
+      rawFee,
+      fee: feeString,
+      balanceError
+    };
+  } catch (e) {
+    return {
+      fee: `0.0000 ${symbol}`,
+      balanceError: false
+    };
+  }
+}
+export async function getAstarUnbondingExtrinsic(substrateApi, amount, dappAddress) {
+  const apiPromise = await substrateApi.isReady;
+  const binaryAmount = new 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 = 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 = parseRawNumber(chunk.unlockEra);
+    const amount = 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) * _STAKING_ERA_LENGTH_MAP[networkKey];
+  return {
+    nextWithdrawal,
+    nextWithdrawalAmount,
+    redeemable
+  };
+}
+export async function handleAstarUnlockingInfo(substrateApi, chainInfo, networkKey, address, type) {
+  const {
+    nextWithdrawal,
+    nextWithdrawalAmount,
+    redeemable
+  } = await getAstarUnlockingInfo(substrateApi, address, networkKey);
+  const {
+    decimals
+  } = _getChainNativeTokenBasicInfo(chainInfo);
+  const parsedRedeemable = redeemable / 10 ** decimals;
+  const parsedNextWithdrawalAmount = nextWithdrawalAmount / 10 ** decimals;
+  return {
+    address,
+    type,
+    chain: networkKey,
+    nextWithdrawal: nextWithdrawal,
+    redeemable: parsedRedeemable,
+    nextWithdrawalAmount: parsedNextWithdrawalAmount
+  };
+}
+export async function getAstarWithdrawalTxInfo(substrateApi, address) {
+  const apiPromise = await substrateApi.isReady;
+  const extrinsic = apiPromise.api.tx.dappsStaking.withdrawUnbonded();
+  return extrinsic.paymentInfo(address);
+}
+export async function handleAstarWithdrawalTxInfo(networkKey, chainInfo, substrateApiMap, evmApiMap, address) {
+  const [txInfo, balance] = await Promise.all([getAstarWithdrawalTxInfo(substrateApiMap[networkKey], address), getFreeBalance(networkKey, address, substrateApiMap, evmApiMap)]);
+  const {
+    decimals,
+    symbol
+  } = _getChainNativeTokenBasicInfo(chainInfo);
+  const feeString = parseNumberToDisplay(txInfo.partialFee, decimals) + ` ${symbol}`;
+  const rawFee = parseRawNumber(txInfo.partialFee.toString());
+  const binaryBalance = new BN(balance);
+  const balanceError = txInfo.partialFee.gt(binaryBalance);
+  return {
+    rawFee,
+    fee: feeString,
+    balanceError
+  };
+}
+export async function getAstarWithdrawalExtrinsic(substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.dappsStaking.withdrawUnbonded();
+}
+export 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 = 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 BN(staked.replaceAll(',', ''));
+      const parsedEra = parseRawNumber(era);
+      if (bnStaked.eq(new BN(0))) {
+        continue;
+      }
+      const nextEraData = (_stakes = stakes[i + 1]) !== null && _stakes !== void 0 ? _stakes : null;
+      const nextEra = nextEraData && 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);
+}
+export async function handleAstarClaimRewardTxInfo(address, networkKey, chainInfo, substrateApiMap, evmApiMap) {
+  const {
+    decimals,
+    symbol
+  } = _getChainNativeTokenBasicInfo(chainInfo);
+  try {
+    const [txInfo, balance] = await Promise.all([getAstarClaimRewardTxInfo(substrateApiMap[networkKey], address), getFreeBalance(networkKey, address, substrateApiMap, evmApiMap)]);
+    const feeString = parseNumberToDisplay(txInfo.partialFee, decimals) + ` ${symbol}`;
+    const rawFee = parseRawNumber(txInfo.partialFee.toString());
+    const binaryBalance = new BN(balance);
+    const balanceError = txInfo.partialFee.gt(binaryBalance);
+    return {
+      rawFee,
+      fee: feeString,
+      balanceError
+    };
+  } catch (e) {
+    return {
+      fee: `0.0000 ${symbol}`,
+      balanceError: false
+    };
+  }
+}
+export 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 = 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 BN(staked.replaceAll(',', ''));
+      const parsedEra = parseRawNumber(era);
+      if (bnStaked.eq(new BN(0))) {
+        continue;
+      }
+      const nextEraData = (_stakes2 = stakes[i + 1]) !== null && _stakes2 !== void 0 ? _stakes2 : null;
+      const nextEra = nextEraData && 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/koni/api/staking/bonding/index.d.ts

@@ -0,0 +1,12 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ChainStakingMetadata, NominatorMetadata, StakingType, UnstakingInfo, ValidatorInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare function getChainStakingMetadata(chain: string, substrateApi: _SubstrateApi): Promise<ChainStakingMetadata>;
+export declare function getNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi): Promise<NominatorMetadata | undefined>;
+export declare function getValidatorsInfo(networkKey: string, substrateApi: _SubstrateApi, decimals: number, chainStakingMetadata: ChainStakingMetadata): Promise<ValidatorInfo[]>;
+export declare function getNominationPoolsInfo(chain: string, substrateApi: _SubstrateApi): Promise<import("@subwallet/extension-base/background/KoniTypes").NominationPoolInfo[]>;
+export declare function getBondingExtrinsic(chainInfo: _ChainInfo, amount: string, nominatorMetadata: NominatorMetadata, selectedValidators: ValidatorInfo[], substrateApi: _SubstrateApi): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getUnbondingExtrinsic(nominatorMetadata: NominatorMetadata, amount: string, chain: string, substrateApi: _SubstrateApi, selectedValidator?: string): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getWithdrawalExtrinsic(substrateApi: _SubstrateApi, chain: string, nominatorMetadata: NominatorMetadata, validatorAddress?: string): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getClaimRewardExtrinsic(substrateApi: _SubstrateApi, chain: string, address: string, stakingType: StakingType, bondReward?: boolean): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getCancelWithdrawalExtrinsic(substrateApi: _SubstrateApi, chain: string, selectedUnstaking: UnstakingInfo): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;

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

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

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

@@ -0,0 +1,12 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ChainStakingMetadata, NominatorMetadata, UnstakingInfo, ValidatorInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export declare function getParaChainStakingMetadata(chain: string, substrateApi: _SubstrateApi): Promise<ChainStakingMetadata>;
+export declare function getParaChainNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi): Promise<NominatorMetadata | undefined>;
+export declare function getParachainCollatorsInfo(chain: string, substrateApi: _SubstrateApi): Promise<ValidatorInfo[]>;
+export declare function getParaBondingExtrinsic(nominatorMetadata: NominatorMetadata, chainInfo: _ChainInfo, substrateApi: _SubstrateApi, amount: string, selectedCollatorInfo: ValidatorInfo): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getParaUnbondingExtrinsic(substrateApi: _SubstrateApi, amount: string, nominatorMetadata: NominatorMetadata, selectedValidator: string): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getParaWithdrawalExtrinsic(substrateApi: _SubstrateApi, address: string, collatorAddress: string): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getTuringCompoundExtrinsic(substrateApi: _SubstrateApi, address: string, collatorAddress: string, accountMinimum: string, bondedAmount: string): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getTuringCancelCompoundingExtrinsic(substrateApi: _SubstrateApi, taskId: string): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getParaCancelWithdrawalExtrinsic(substrateApi: _SubstrateApi, selectedUnstaking: UnstakingInfo): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;