@subwallet/extension-base 1.1.35-0 → 1.1.35-beta.0

package/services/earning-service/handlers/native-staking/astar.js

@@ -0,0 +1,456 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { getEarningStatusByNominations } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
+import { EarningStatus, UnstakingStatus, YieldStepType } from '@subwallet/extension-base/types';
+import { balanceFormatter, formatNumber, isUrl, parseRawNumber, reformatAddress } from '@subwallet/extension-base/utils';
+import fetch from 'cross-fetch';
+import { BN, BN_ZERO } from '@polkadot/util';
+import { isEthereumAddress } from '@polkadot/util-crypto';
+import BaseParaNativeStakingPoolHandler from "./base-para.js";
+const convertAddress = address => {
+  return isEthereumAddress(address) ? address.toLowerCase() : address;
+};
+export function getAstarWithdrawable(yieldPosition) {
+  const unstakingInfo = {
+    chain: yieldPosition.chain,
+    status: UnstakingStatus.CLAIMABLE,
+    claimable: '0',
+    waitingTime: 0
+  };
+  let bnWithdrawable = BN_ZERO;
+  for (const unstaking of yieldPosition.unstakings) {
+    if (unstaking.status === UnstakingStatus.CLAIMABLE) {
+      bnWithdrawable = bnWithdrawable.add(new BN(unstaking.claimable));
+    }
+  }
+  if (bnWithdrawable.gt(BN_ZERO)) {
+    unstakingInfo.claimable = bnWithdrawable.toString();
+    return unstakingInfo;
+  } else {
+    return undefined;
+  }
+}
+export default class AstarNativeStakingPoolHandler extends BaseParaNativeStakingPoolHandler {
+  availableMethod = {
+    join: true,
+    defaultUnstake: true,
+    fastUnstake: false,
+    cancelUnstake: false,
+    withdraw: true,
+    claimReward: true
+  };
+
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    let cancel = false;
+    const nativeToken = this.nativeToken;
+    const defaultCallback = async () => {
+      const data = {
+        ...this.baseInfo,
+        type: this.type,
+        metadata: {
+          ...this.metadataInfo,
+          description: this.getDescription()
+        }
+      };
+      const poolInfo = await this.getPoolInfo();
+      !poolInfo && callback(data);
+    };
+    if (!this.isActive) {
+      await defaultCallback();
+      return () => {
+        cancel = true;
+      };
+    }
+    await defaultCallback();
+    const apyPromise = new Promise(resolve => {
+      fetch(`https://api.astar.network/api/v1/${this.chain}/dapps-staking/apy`, {
+        method: 'GET'
+      }).then(resp => {
+        resolve(resp.json());
+      }).catch(e => {
+        console.error(e);
+        resolve(null);
+      });
+    });
+    const timeout = new Promise(resolve => {
+      const id = setTimeout(() => {
+        clearTimeout(id);
+        resolve(null);
+      }, 8000);
+    });
+    const apyRacePromise = Promise.race([timeout, apyPromise]); // need race because API often timeout
+
+    const substrateApi = await this.substrateApi.isReady;
+    let apyInfo;
+    try {
+      apyInfo = await apyRacePromise;
+    } catch (e) {
+      apyInfo = null;
+    }
+    const unsub = await substrateApi.api.query.dappsStaking.currentEra(_currentEra => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      const era = _currentEra.toString();
+      const minDelegatorStake = substrateApi.api.consts.dappsStaking.minimumStakingAmount.toString();
+      const unstakingDelay = substrateApi.api.consts.dappsStaking.unbondingPeriod.toString();
+      const eraTime = _STAKING_ERA_LENGTH_MAP[this.chain] || _STAKING_ERA_LENGTH_MAP.default; // in hours
+      const unstakingPeriod = parseInt(unstakingDelay) * eraTime;
+      const minToHuman = formatNumber(minDelegatorStake, nativeToken.decimals || 0, balanceFormatter);
+      const data = {
+        ...this.baseInfo,
+        type: this.type,
+        metadata: {
+          ...this.metadataInfo,
+          description: this.getDescription(minToHuman)
+        },
+        statistic: {
+          assetEarning: [{
+            slug: this.nativeToken.slug,
+            apy: apyInfo !== null ? apyInfo : undefined
+          }],
+          maxCandidatePerFarmer: 100,
+          // temporary fix for Astar, there's no limit for now
+          maxWithdrawalRequestPerFarmer: 1,
+          // by default
+          earningThreshold: {
+            join: minDelegatorStake,
+            defaultUnstake: '0',
+            fastUnstake: '0'
+          },
+          farmerCount: 0,
+          // TODO recheck
+          era: parseInt(era),
+          eraTime,
+          tvl: undefined,
+          // TODO recheck
+          totalApy: apyInfo !== null ? apyInfo : undefined,
+          // TODO recheck
+          unstakingPeriod
+        }
+      };
+      callback(data);
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool position */
+
+  async parseNominatorMetadata(chainInfo, address, substrateApi, ledger) {
+    const nominationList = [];
+    const unstakingList = [];
+    const allDappsReq = new Promise(resolve => {
+      fetch(`https://api.astar.network/api/v1/${chainInfo.slug}/dapps-staking/dapps`, {
+        method: 'GET'
+      }).then(resp => {
+        resolve(resp.json());
+      }).catch(console.error);
+    });
+    const [_allDapps, _era, _stakerInfo] = await Promise.all([allDappsReq, substrateApi.api.query.dappsStaking.currentEra(), substrateApi.api.query.dappsStaking.generalStakerInfo.entries(address)]);
+    const currentEra = _era.toString();
+    const minDelegatorStake = substrateApi.api.consts.dappsStaking.minimumStakingAmount.toString();
+    const allDapps = _allDapps;
+    let bnTotalActiveStake = BN_ZERO;
+    if (_stakerInfo.length > 0) {
+      const dAppInfoMap = {};
+      allDapps.forEach(dappInfo => {
+        dAppInfoMap[convertAddress(dappInfo.address)] = 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 ? stakedDapp.Evm.toLowerCase() : stakedDapp.Wasm;
+        const dappAddress = convertAddress(_dappAddress);
+        const currentStake = stakeList.slice(-1)[0].staked.toString() || '0';
+        const bnCurrentStake = new BN(currentStake);
+        if (bnCurrentStake.gt(BN_ZERO)) {
+          const dappEarningStatus = bnCurrentStake.gt(BN_ZERO) && bnCurrentStake.gte(new BN(minDelegatorStake)) ? EarningStatus.EARNING_REWARD : EarningStatus.NOT_EARNING;
+          bnTotalActiveStake = bnTotalActiveStake.add(bnCurrentStake);
+          const dappInfo = dAppInfoMap[dappAddress];
+          nominationList.push({
+            status: dappEarningStatus,
+            chain: chainInfo.slug,
+            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) {
+      for (const unlockingChunk of unlockingChunks) {
+        const isClaimable = unlockingChunk.unlockEra - parseInt(currentEra) < 0;
+        const remainingEra = unlockingChunk.unlockEra - parseInt(currentEra);
+        const waitingTime = remainingEra * _STAKING_ERA_LENGTH_MAP[chainInfo.slug];
+        unstakingList.push({
+          chain: chainInfo.slug,
+          status: isClaimable ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
+          claimable: unlockingChunk.amount.toString(),
+          waitingTime
+        });
+      }
+    }
+    if (nominationList.length === 0 && unstakingList.length === 0) {
+      return {
+        balanceToken: this.nativeToken.slug,
+        totalStake: '0',
+        unstakeBalance: '0',
+        status: EarningStatus.NOT_STAKING,
+        isBondedBefore: false,
+        activeStake: '0',
+        nominations: [],
+        unstakings: []
+      };
+    }
+    const stakingStatus = getEarningStatusByNominations(bnTotalActiveStake, nominationList);
+    const activeStake = bnTotalActiveStake.toString();
+    const unstakeBalance = unstakingList.reduce((old, currentValue) => {
+      return old.add(new BN(currentValue.claimable));
+    }, BN_ZERO);
+    const totalStake = unstakeBalance.add(bnTotalActiveStake);
+    return {
+      status: stakingStatus,
+      balanceToken: this.nativeToken.slug,
+      totalStake: totalStake.toString(),
+      activeStake: activeStake,
+      unstakeBalance: unstakeBalance.toString(),
+      isBondedBefore: totalStake.gt(BN_ZERO),
+      nominations: nominationList,
+      unstakings: unstakingList
+    };
+  }
+  async subscribePoolPosition(useAddresses, resultCallback) {
+    let cancel = false;
+    const substrateApi = await this.substrateApi.isReady;
+    const defaultInfo = this.baseInfo;
+    const chainInfo = this.chainInfo;
+    const unsub = await substrateApi.api.query.dappsStaking.ledger.multi(useAddresses, async ledgers => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      if (ledgers) {
+        await Promise.all(ledgers.map(async (_ledger, i) => {
+          const owner = reformatAddress(useAddresses[i], 42);
+          const ledger = _ledger.toPrimitive();
+          if (ledger && ledger.locked > 0) {
+            const nominatorMetadata = await this.parseNominatorMetadata(chainInfo, owner, substrateApi, ledger);
+            resultCallback({
+              ...defaultInfo,
+              ...nominatorMetadata,
+              address: owner,
+              type: this.type
+            });
+          } else {
+            resultCallback({
+              ...defaultInfo,
+              type: this.type,
+              address: owner,
+              balanceToken: this.nativeToken.slug,
+              totalStake: '0',
+              activeStake: '0',
+              unstakeBalance: '0',
+              isBondedBefore: false,
+              status: EarningStatus.NOT_STAKING,
+              nominations: [],
+              unstakings: []
+            });
+          }
+        }));
+      }
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Get pool targets */
+
+  async getPoolTargets() {
+    const chainApi = await this.substrateApi.isReady;
+    const rawMaxStakerPerContract = chainApi.api.consts.dappsStaking.maxNumberOfStakersPerContract.toHuman();
+    const allDappsInfo = [];
+    const maxStakerPerContract = parseRawNumber(rawMaxStakerPerContract);
+    const allDappsReq = new Promise(resolve => {
+      fetch(`https://api.astar.network/api/v1/${this.chain}/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: convertAddress(dappAddress),
+        totalStake: totalStake,
+        ownStake: '0',
+        otherStake: totalStake.toString(),
+        nominatorCount: stakerCount,
+        blocked: false,
+        isVerified: false,
+        minBond: '0',
+        icon: dappIcon,
+        identity: dappName,
+        chain: this.chain,
+        isCrowded: stakerCount >= maxStakerPerContract
+      });
+    }));
+    return allDappsInfo;
+  }
+
+  /* Get pool targets */
+
+  /* Join pool action */
+
+  get defaultSubmitStep() {
+    return [{
+      name: 'Nominate dApps',
+      type: YieldStepType.NOMINATE
+    }, {
+      slug: this.nativeToken.slug,
+      amount: '0'
+    }];
+  }
+  async createJoinExtrinsic(data, positionInfo, bondDest = 'Staked') {
+    const {
+      amount,
+      selectedValidators: targetValidators
+    } = data;
+    const chainApi = await this.substrateApi.isReady;
+    const binaryAmount = new BN(amount);
+    const dappInfo = targetValidators[0];
+    const dappParam = isEthereumAddress(dappInfo.address) ? {
+      Evm: dappInfo.address
+    } : {
+      Wasm: dappInfo.address
+    };
+    const extrinsic = chainApi.api.tx.dappsStaking.bondAndStake(dappParam, binaryAmount);
+    const tokenSlug = this.nativeToken.slug;
+    // const feeInfo = await extrinsic.paymentInfo(address);
+    // const fee = feeInfo.toPrimitive() as unknown as RuntimeDispatchInfo;
+
+    // Not use the fee to validate and to display on UI
+    return [extrinsic, {
+      slug: tokenSlug,
+      amount: '0'
+    }];
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const chainApi = await this.substrateApi.isReady;
+    const binaryAmount = new BN(amount);
+    if (!selectedTarget) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
+    }
+    const dappParam = isEthereumAddress(selectedTarget) ? {
+      Evm: selectedTarget
+    } : {
+      Wasm: selectedTarget
+    };
+    const extrinsic = chainApi.api.tx.dappsStaking.unbondAndUnstake(dappParam, binaryAmount);
+    return [ExtrinsicType.STAKING_LEAVE_POOL, extrinsic];
+  }
+
+  /* Leave pool action */
+
+  /* Other action */
+
+  async handleYieldCancelUnstake(params) {
+    return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+  }
+  async handleYieldWithdraw(address, unstakingInfo) {
+    const chainApi = await this.substrateApi.isReady;
+    return chainApi.api.tx.dappsStaking.withdrawUnbonded();
+  }
+  async handleYieldClaimReward(address, bondReward) {
+    const apiPromise = await this.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 = isEthereumAddress(stakedDapp.Evm) ? stakedDapp.Evm.toLowerCase() : stakedDapp.Evm;
+      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);
+      }
+    }
+    return apiPromise.api.tx.utility.batch(transactions);
+  }
+
+  /* Other actions */
+}

package/services/earning-service/handlers/native-staking/base-para.d.ts

@@ -0,0 +1,11 @@
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import BaseNativeStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/native-staking/base';
+import { OptimalYieldPath, SubmitYieldJoinData, YieldStepBaseInfo } from '@subwallet/extension-base/types';
+export default abstract class BaseParaNativeStakingPoolHandler extends BaseNativeStakingPoolHandler {
+    get defaultSubmitStep(): YieldStepBaseInfo;
+    validateYieldJoin(data: SubmitYieldJoinData, path: OptimalYieldPath): Promise<TransactionError[]>;
+    /**
+     * @todo Recheck
+     * */
+    validateYieldLeave(amount: string, address: string, fastLeave: boolean, selectedTarget?: string): Promise<TransactionError[]>;
+}

package/services/earning-service/handlers/native-staking/base-para.js

@@ -0,0 +1,138 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { BasicTxErrorType, StakingTxErrorType, StakingType } from '@subwallet/extension-base/background/KoniTypes';
+import { getBondedValidators, getExistUnstakeErrorMessage, getMaxValidatorErrorMessage, getMinStakeErrorMessage } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import BaseNativeStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/native-staking/base';
+import { EarningStatus, YieldStepType } from '@subwallet/extension-base/types';
+import { isSameAddress, reformatAddress } from '@subwallet/extension-base/utils';
+import { t } from 'i18next';
+import { BN, BN_ZERO } from '@polkadot/util';
+export default class BaseParaNativeStakingPoolHandler extends BaseNativeStakingPoolHandler {
+  /* Join pool action */
+
+  get defaultSubmitStep() {
+    return [{
+      name: 'Nominate collators',
+      type: YieldStepType.NOMINATE
+    }, {
+      slug: this.nativeToken.slug,
+      amount: '0'
+    }];
+  }
+  async validateYieldJoin(data, path) {
+    const {
+      address,
+      amount,
+      selectedValidators
+    } = data;
+    const poolInfo = await this.getPoolInfo();
+    const poolPosition = await this.getPoolPosition(address);
+    const chainInfo = this.chainInfo;
+    const bnAmount = new BN(amount);
+    if (bnAmount.lte(BN_ZERO)) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    if (!poolInfo || !poolInfo.statistic) {
+      return Promise.resolve([new TransactionError(BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const errors = [];
+    const selectedCollator = selectedValidators[0];
+    let bnTotalStake = new BN(amount);
+    const bnChainMinStake = new BN(poolInfo.statistic.earningThreshold.join || '0');
+    const bnCollatorMinStake = new BN(selectedCollator.minBond || '0');
+    const bnMinStake = bnCollatorMinStake > bnChainMinStake ? bnCollatorMinStake : bnChainMinStake;
+    const minStakeErrorMessage = getMinStakeErrorMessage(chainInfo, bnMinStake);
+    const maxValidator = poolInfo.statistic.maxCandidatePerFarmer;
+    const maxValidatorErrorMessage = getMaxValidatorErrorMessage(chainInfo, maxValidator);
+    const existUnstakeErrorMessage = getExistUnstakeErrorMessage(chainInfo.slug, StakingType.NOMINATED, true);
+    if (!poolPosition || poolPosition.status === EarningStatus.NOT_STAKING) {
+      if (!bnTotalStake.gte(bnMinStake)) {
+        errors.push(new TransactionError(StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
+      }
+      return errors;
+    }
+    const {
+      bondedValidators
+    } = getBondedValidators(poolPosition.nominations);
+    const parsedSelectedCollatorAddress = reformatAddress(selectedCollator.address, 0);
+    if (!bondedValidators.includes(parsedSelectedCollatorAddress)) {
+      // new delegation
+      if (!bnTotalStake.gte(bnMinStake)) {
+        errors.push(new TransactionError(StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
+      }
+      const delegationCount = poolPosition.nominations.length + 1;
+      if (delegationCount > maxValidator) {
+        errors.push(new TransactionError(StakingTxErrorType.EXCEED_MAX_NOMINATIONS, maxValidatorErrorMessage));
+      }
+    } else {
+      let currentDelegationAmount = '0';
+      let hasUnstaking = false;
+      for (const delegation of poolPosition.nominations) {
+        if (reformatAddress(delegation.validatorAddress, 0) === parsedSelectedCollatorAddress) {
+          currentDelegationAmount = delegation.activeStake;
+          hasUnstaking = !!delegation.hasUnstaking && delegation.hasUnstaking;
+          break;
+        }
+      }
+      bnTotalStake = bnTotalStake.add(new BN(currentDelegationAmount));
+      if (!bnTotalStake.gte(bnMinStake)) {
+        errors.push(new TransactionError(StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
+      }
+      if (hasUnstaking) {
+        errors.push(new TransactionError(StakingTxErrorType.EXIST_UNSTAKING_REQUEST, existUnstakeErrorMessage));
+      }
+    }
+    return errors;
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  /**
+   * @todo Recheck
+   * */
+  async validateYieldLeave(amount, address, fastLeave, selectedTarget) {
+    const errors = [];
+    const poolInfo = await this.getPoolInfo();
+    const poolPosition = await this.getPoolPosition(address);
+    if (!poolInfo || !poolInfo.statistic || !poolPosition || fastLeave || !selectedTarget) {
+      return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (fastLeave) {
+      return [new TransactionError(BasicTxErrorType.INVALID_PARAMS)];
+    }
+    const bnAmount = new BN(amount);
+    if (bnAmount.lte(BN_ZERO)) {
+      errors.push(new TransactionError(BasicTxErrorType.INVALID_PARAMS, t('Amount must be greater than 0')));
+    }
+    let targetNomination;
+    for (const nomination of poolPosition.nominations) {
+      if (isSameAddress(nomination.validatorAddress, selectedTarget)) {
+        targetNomination = nomination;
+        break;
+      }
+    }
+    if (!targetNomination) {
+      errors.push(new TransactionError(BasicTxErrorType.INTERNAL_ERROR));
+      return errors;
+    }
+    const bnActiveStake = new BN(targetNomination.activeStake);
+    const bnRemainingStake = bnActiveStake.sub(new BN(amount));
+    const bnChainMinStake = new BN(poolInfo.statistic.earningThreshold.join || '0');
+    const bnCollatorMinStake = new BN(targetNomination.validatorMinStake || '0');
+    const bnMinStake = BN.max(bnCollatorMinStake, bnChainMinStake);
+    const existUnstakeErrorMessage = getExistUnstakeErrorMessage(this.chain, StakingType.NOMINATED);
+    if (targetNomination.hasUnstaking) {
+      errors.push(new TransactionError(StakingTxErrorType.EXIST_UNSTAKING_REQUEST, existUnstakeErrorMessage));
+    }
+    if (!(bnRemainingStake.isZero() || bnRemainingStake.gte(bnMinStake))) {
+      errors.push(new TransactionError(StakingTxErrorType.INVALID_ACTIVE_STAKE));
+    }
+    return errors;
+  }
+
+  /* Leave pool action */
+}

package/services/earning-service/handlers/native-staking/base.d.ts

@@ -0,0 +1,21 @@
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { EarningRewardHistoryItem, EarningRewardItem, HandleYieldStepData, OptimalYieldPath, OptimalYieldPathParams, SubmitJoinNativeStaking, SubmitYieldJoinData, TransactionData, YieldPoolMethodInfo, YieldPoolType, YieldPositionInfo, YieldStepBaseInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import BasePoolHandler from '../base';
+export default abstract class BaseNativeStakingPoolHandler extends BasePoolHandler {
+    readonly type = YieldPoolType.NATIVE_STAKING;
+    protected readonly name: string;
+    protected readonly shortName: string;
+    slug: string;
+    protected readonly availableMethod: YieldPoolMethodInfo;
+    constructor(state: KoniState, chain: string);
+    protected getDescription(amount?: string): string;
+    getPoolReward(useAddresses: string[], callBack: (rs: EarningRewardItem) => void): Promise<VoidFunction>;
+    getPoolRewardHistory(useAddresses: string[], callBack: (rs: EarningRewardHistoryItem) => void): Promise<VoidFunction>;
+    get defaultSubmitStep(): YieldStepBaseInfo;
+    abstract createJoinExtrinsic(data: SubmitJoinNativeStaking, positionInfo?: YieldPositionInfo, bondDest?: string): Promise<[TransactionData, YieldTokenBaseInfo]>;
+    protected getSubmitStep(params: OptimalYieldPathParams): Promise<YieldStepBaseInfo>;
+    handleYieldJoin(_data: SubmitYieldJoinData, path: OptimalYieldPath, currentStep: number): Promise<HandleYieldStepData>;
+    handleYieldRedeem(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+    handleYieldClaimReward(address: string, bondReward?: boolean): Promise<TransactionData>;
+}