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

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

@@ -0,0 +1,242 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { StakingStatus, StakingType, UnstakingStatus } from '@subwallet/extension-base/background/KoniTypes';
+import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
+import { isUrl, 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({
+          status: 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 * _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,
+    status: StakingStatus.NOT_EARNING // TODO
+  };
+}
+
+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 contractParam = 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;
+}
+export async function getAstarBondingExtrinsic(substrateApi, amount, dappInfo) {
+  const chainApi = await substrateApi.isReady;
+  const binaryAmount = new BN(amount);
+  const dappParam = isEthereumAddress(dappInfo.address) ? {
+    Evm: dappInfo.address
+  } : {
+    Wasm: dappInfo.address
+  };
+  return chainApi.api.tx.dappsStaking.bondAndStake(dappParam, binaryAmount);
+}
+export async function getAstarUnbondingExtrinsic(substrateApi, amount, dappAddress) {
+  const apiPromise = await substrateApi.isReady;
+  const binaryAmount = new BN(amount);
+  const dappParam = isEthereumAddress(dappAddress) ? {
+    Evm: dappAddress
+  } : {
+    Wasm: dappAddress
+  };
+  return apiPromise.api.tx.dappsStaking.unbondAndUnstake(dappParam, binaryAmount);
+}
+export async function getAstarWithdrawalExtrinsic(substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.dappsStaking.withdrawUnbonded();
+}
+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 _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;
+    }
+    const dappParam = 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/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, selectedValidators: ValidatorInfo[], substrateApi: _SubstrateApi, address: string, nominatorMetadata?: NominatorMetadata): 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, selectedValidators, substrateApi, address, nominatorMetadata) {
+  if (_STAKING_CHAIN_GROUP.para.includes(chainInfo.slug)) {
+    return getParaBondingExtrinsic(chainInfo, substrateApi, amount, selectedValidators[0], nominatorMetadata); // 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(substrateApi, amount, selectedValidators[0], nominatorMetadata);
+  }
+  return getRelayBondingExtrinsic(substrateApi, amount, selectedValidators, chainInfo, address, nominatorMetadata);
+}
+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(chainInfo: _ChainInfo, substrateApi: _SubstrateApi, amount: string, selectedCollatorInfo: ValidatorInfo, nominatorMetadata?: NominatorMetadata): 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>>;

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

@@ -0,0 +1,246 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { StakingStatus, StakingType, UnstakingStatus } from '@subwallet/extension-base/background/KoniTypes';
+import { getBondedValidators, getParaCurrentInflation, isUnstakeAll, parseIdentity } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _isChainEvmCompatible } from '@subwallet/extension-base/services/chain-service/utils';
+import { parseRawNumber, reformatAddress } from '@subwallet/extension-base/utils';
+import { BN, BN_ZERO } from '@polkadot/util';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+export async function getParaChainStakingMetadata(chain, substrateApi) {
+  const chainApi = await substrateApi.isReady;
+  const _round = (await chainApi.api.query.parachainStaking.round()).toHuman();
+  const round = 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 BN(rawUnvestedAllocation);
+  }
+  const totalStake = _totalStake ? new BN(_totalStake.toString()) : BN_ZERO;
+  const totalIssuance = new 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 = getParaCurrentInflation(parseRawNumber(totalStake.toString()), inflationConfig);
+  const unstakingPeriod = parseInt(unstakingDelay) * _STAKING_ERA_LENGTH_MAP[chain];
+  return {
+    chain,
+    type: StakingType.NOMINATED,
+    era: round,
+    inflation,
+    minStake: '0',
+    maxValidatorPerNominator: parseInt(maxDelegations),
+    maxWithdrawalRequestPerValidator: 1,
+    // by default
+    allowCancelUnstaking: true,
+    unstakingPeriod
+  };
+}
+export async function getParaChainNominatorMetadata(chainInfo, address, substrateApi) {
+  if (_isChainEvmCompatible(chainInfo) && !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 = 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 = parseIdentity(identityInfo);
+    let hasUnstaking = false;
+
+    // parse unstaking info
+    if (delegationScheduledRequests) {
+      for (const scheduledRequest of delegationScheduledRequests) {
+        if (reformatAddress(scheduledRequest.delegator, 0) === reformatAddress(address, 0)) {
+          // add network prefix
+          const isClaimable = scheduledRequest.whenExecutable - currentRound <= 0;
+          const remainingEra = scheduledRequest.whenExecutable - (currentRound + 1);
+          const waitingTime = remainingEra * _STAKING_ERA_LENGTH_MAP[chain];
+          const claimable = Object.values(scheduledRequest.action)[0];
+          unstakingMap[delegation.owner] = {
+            chain,
+            status: isClaimable ? UnstakingStatus.CLAIMABLE : 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 BN(delegation.amount);
+    const bnUnstakeBalance = unstakingMap[delegation.owner] ? new BN(unstakingMap[delegation.owner].claimable) : BN_ZERO;
+    const bnActiveStake = bnStake.sub(bnUnstakeBalance);
+    bnTotalActiveStake = bnTotalActiveStake.add(bnActiveStake);
+    nominationList.push({
+      chain,
+      status: 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: StakingType.NOMINATED,
+    address: address,
+    activeStake: bnTotalActiveStake.toString(),
+    nominations: nominationList,
+    unstakings: Object.values(unstakingMap)
+  };
+}
+export 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 BN(rawBond.replaceAll(',', ''));
+    const delegationCount = parseRawNumber(rawInfo === null || rawInfo === void 0 ? void 0 : rawInfo.delegationCount);
+    const minDelegation = 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 = 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;
+}
+export async function getParaBondingExtrinsic(chainInfo, substrateApi, amount, selectedCollatorInfo, nominatorMetadata) {
+  const apiPromise = await substrateApi.isReady;
+  const binaryAmount = new BN(amount);
+  if (!nominatorMetadata) {
+    return apiPromise.api.tx.parachainStaking.delegate(selectedCollatorInfo.address, binaryAmount, new BN(selectedCollatorInfo.nominatorCount), 0);
+  }
+  const {
+    bondedValidators,
+    nominationCount
+  } = getBondedValidators(nominatorMetadata.nominations);
+  const parsedSelectedCollatorAddress = reformatAddress(selectedCollatorInfo.address, 0);
+  if (!bondedValidators.includes(parsedSelectedCollatorAddress)) {
+    return apiPromise.api.tx.parachainStaking.delegate(selectedCollatorInfo.address, binaryAmount, new BN(selectedCollatorInfo.nominatorCount), nominationCount);
+  } else {
+    return apiPromise.api.tx.parachainStaking.delegatorBondMore(selectedCollatorInfo.address, binaryAmount);
+  }
+}
+export async function getParaUnbondingExtrinsic(substrateApi, amount, nominatorMetadata, selectedValidator) {
+  const apiPromise = await substrateApi.isReady;
+  const binaryAmount = new BN(amount);
+  const unstakeAll = isUnstakeAll(selectedValidator, nominatorMetadata.nominations, amount);
+  if (!unstakeAll) {
+    return apiPromise.api.tx.parachainStaking.scheduleDelegatorBondLess(selectedValidator, binaryAmount);
+  } else {
+    return apiPromise.api.tx.parachainStaking.scheduleRevokeDelegation(selectedValidator);
+  }
+}
+export async function getParaWithdrawalExtrinsic(substrateApi, address, collatorAddress) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.parachainStaking.executeDelegationRequest(address, collatorAddress);
+}
+export 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);
+}
+export async function getTuringCancelCompoundingExtrinsic(substrateApi, taskId) {
+  const apiPromise = await substrateApi.isReady;
+  return apiPromise.api.tx.automationTime.cancelTask(taskId);
+}
+export async function getParaCancelWithdrawalExtrinsic(substrateApi, selectedUnstaking) {
+  const chainApi = await substrateApi.isReady;
+  return chainApi.api.tx.parachainStaking.cancelDelegationRequest(selectedUnstaking.validatorAddress);
+}

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

@@ -0,0 +1,32 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ChainStakingMetadata, NominationPoolInfo, NominatorMetadata, UnstakingInfo, ValidatorInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+export interface PalletStakingNominations {
+    targets: string[];
+    submittedIn: number;
+    suppressed: boolean;
+}
+export interface UnlockingChunk {
+    value: number;
+    era: number;
+}
+export interface PalletStakingStakingLedger {
+    stash: string;
+    total: number;
+    active: number;
+    unlocking: UnlockingChunk[];
+    claimedRewards: number[];
+}
+export declare function getRelayChainStakingMetadata(chain: string, substrateApi: _SubstrateApi): Promise<ChainStakingMetadata>;
+export declare function getRelayChainNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi): Promise<NominatorMetadata | undefined>;
+export declare function getRelayChainPoolMemberMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi): Promise<NominatorMetadata | undefined>;
+export declare function getRelayValidatorsInfo(chain: string, substrateApi: _SubstrateApi, decimals: number, chainStakingMetadata: ChainStakingMetadata): Promise<ValidatorInfo[]>;
+export declare function getRelayPoolsInfo(chain: string, substrateApi: _SubstrateApi): Promise<NominationPoolInfo[]>;
+export declare function getRelayBondingExtrinsic(substrateApi: _SubstrateApi, amount: string, targetValidators: ValidatorInfo[], chainInfo: _ChainInfo, address: string, nominatorMetadata?: NominatorMetadata, bondDest?: string): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getRelayUnbondingExtrinsic(substrateApi: _SubstrateApi, amount: string, nominatorMetadata: NominatorMetadata): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getRelayWithdrawalExtrinsic(substrateApi: _SubstrateApi, address: string): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getRelayCancelWithdrawalExtrinsic(substrateApi: _SubstrateApi, selectedUnstaking: UnstakingInfo): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getPoolingClaimRewardExtrinsic(substrateApi: _SubstrateApi, bondReward?: boolean): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getPoolingBondingExtrinsic(substrateApi: _SubstrateApi, amount: string, selectedPoolId: number, nominatorMetadata: NominatorMetadata | undefined): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getPoolingUnbondingExtrinsic(substrateApi: _SubstrateApi, amount: string, nominatorMetadata: NominatorMetadata): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+export declare function getPoolingWithdrawalExtrinsic(substrateApi: _SubstrateApi, nominatorMetadata: NominatorMetadata): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;