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

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

@@ -0,0 +1,466 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.getAstarWithdrawable = getAstarWithdrawable;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/koni/api/staking/bonding/utils");
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _types = require("@subwallet/extension-base/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _crossFetch = _interopRequireDefault(require("cross-fetch"));
+var _util = require("@polkadot/util");
+var _utilCrypto = require("@polkadot/util-crypto");
+var _basePara = _interopRequireDefault(require("./base-para"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const convertAddress = address => {
+  return (0, _utilCrypto.isEthereumAddress)(address) ? address.toLowerCase() : address;
+};
+function getAstarWithdrawable(yieldPosition) {
+  const unstakingInfo = {
+    chain: yieldPosition.chain,
+    status: _types.UnstakingStatus.CLAIMABLE,
+    claimable: '0',
+    waitingTime: 0
+  };
+  let bnWithdrawable = _util.BN_ZERO;
+  for (const unstaking of yieldPosition.unstakings) {
+    if (unstaking.status === _types.UnstakingStatus.CLAIMABLE) {
+      bnWithdrawable = bnWithdrawable.add(new _util.BN(unstaking.claimable));
+    }
+  }
+  if (bnWithdrawable.gt(_util.BN_ZERO)) {
+    unstakingInfo.claimable = bnWithdrawable.toString();
+    return unstakingInfo;
+  } else {
+    return undefined;
+  }
+}
+class AstarNativeStakingPoolHandler extends _basePara.default {
+  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 => {
+      (0, _crossFetch.default)(`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 = _constants._STAKING_ERA_LENGTH_MAP[this.chain] || _constants._STAKING_ERA_LENGTH_MAP.default; // in hours
+      const unstakingPeriod = parseInt(unstakingDelay) * eraTime;
+      const minToHuman = (0, _utils2.formatNumber)(minDelegatorStake, nativeToken.decimals || 0, _utils2.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 => {
+      (0, _crossFetch.default)(`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 = _util.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 _util.BN(currentStake);
+        if (bnCurrentStake.gt(_util.BN_ZERO)) {
+          const dappEarningStatus = bnCurrentStake.gt(_util.BN_ZERO) && bnCurrentStake.gte(new _util.BN(minDelegatorStake)) ? _types.EarningStatus.EARNING_REWARD : _types.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 * _constants._STAKING_ERA_LENGTH_MAP[chainInfo.slug];
+        unstakingList.push({
+          chain: chainInfo.slug,
+          status: isClaimable ? _types.UnstakingStatus.CLAIMABLE : _types.UnstakingStatus.UNLOCKING,
+          claimable: unlockingChunk.amount.toString(),
+          waitingTime
+        });
+      }
+    }
+    if (nominationList.length === 0 && unstakingList.length === 0) {
+      return {
+        balanceToken: this.nativeToken.slug,
+        totalStake: '0',
+        unstakeBalance: '0',
+        status: _types.EarningStatus.NOT_STAKING,
+        isBondedBefore: false,
+        activeStake: '0',
+        nominations: [],
+        unstakings: []
+      };
+    }
+    const stakingStatus = (0, _utils.getEarningStatusByNominations)(bnTotalActiveStake, nominationList);
+    const activeStake = bnTotalActiveStake.toString();
+    const unstakeBalance = unstakingList.reduce((old, currentValue) => {
+      return old.add(new _util.BN(currentValue.claimable));
+    }, _util.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(_util.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 = (0, _utils2.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: _types.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 = (0, _utils2.parseRawNumber)(rawMaxStakerPerContract);
+    const allDappsReq = new Promise(resolve => {
+      (0, _crossFetch.default)(`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 = (0, _utils2.parseRawNumber)(_era.toHuman());
+    const allDapps = _allDapps;
+    await Promise.all(allDapps.map(async dapp => {
+      const dappName = dapp.name;
+      const dappAddress = dapp.address;
+      const dappIcon = (0, _utils2.isUrl)(dapp.iconUrl) ? dapp.iconUrl : undefined;
+      const contractParam = (0, _utilCrypto.isEthereumAddress)(dappAddress) ? {
+        Evm: dappAddress
+      } : {
+        Wasm: dappAddress
+      };
+      const _contractInfo = await chainApi.api.query.dappsStaking.contractEraStake(contractParam, era);
+      const contractInfo = _contractInfo.toPrimitive();
+      let totalStake = '0';
+      let stakerCount = 0;
+      if (contractInfo !== null) {
+        var _contractInfo$total;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-assignment
+        totalStake = contractInfo === null || contractInfo === void 0 ? void 0 : (_contractInfo$total = contractInfo.total) === null || _contractInfo$total === void 0 ? void 0 : _contractInfo$total.toString();
+        stakerCount = contractInfo.numberOfStakers;
+      }
+      allDappsInfo.push({
+        commission: 0,
+        expectedReturn: 0,
+        address: 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: _types.YieldStepType.NOMINATE
+    }, {
+      slug: this.nativeToken.slug,
+      amount: '0'
+    }];
+  }
+  async createJoinExtrinsic(data, positionInfo) {
+    let bondDest = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'Staked';
+    const {
+      amount,
+      selectedValidators: targetValidators
+    } = data;
+    const chainApi = await this.substrateApi.isReady;
+    const binaryAmount = new _util.BN(amount);
+    const dappInfo = targetValidators[0];
+    const dappParam = (0, _utilCrypto.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 _util.BN(amount);
+    if (!selectedTarget) {
+      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS));
+    }
+    const dappParam = (0, _utilCrypto.isEthereumAddress)(selectedTarget) ? {
+      Evm: selectedTarget
+    } : {
+      Wasm: selectedTarget
+    };
+    const extrinsic = chainApi.api.tx.dappsStaking.unbondAndUnstake(dappParam, binaryAmount);
+    return [_KoniTypes.ExtrinsicType.STAKING_LEAVE_POOL, extrinsic];
+  }
+
+  /* Leave pool action */
+
+  /* Other action */
+
+  async handleYieldCancelUnstake(params) {
+    return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.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 = (0, _utils2.parseRawNumber)(_currentEra.toHuman());
+    const transactions = [];
+    for (const item of _stakedDapps) {
+      const data = item[0].toHuman();
+      const stakedDapp = data[1];
+      const stakeData = item[1].toHuman();
+      const stakes = stakeData.stakes;
+      const dappAddress = (0, _utilCrypto.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 _util.BN(staked.replaceAll(',', ''));
+        const parsedEra = (0, _utils2.parseRawNumber)(era);
+        if (bnStaked.eq(new _util.BN(0))) {
+          continue;
+        }
+        const nextEraData = (_stakes = stakes[i + 1]) !== null && _stakes !== void 0 ? _stakes : null;
+        const nextEra = nextEraData && (0, _utils2.parseRawNumber)(nextEraData.era);
+        const isLastEra = i === stakes.length - 1;
+        const eraToClaim = isLastEra ? currentEra - parsedEra : nextEra - parsedEra;
+        numberOfUnclaimedEra += eraToClaim;
+      }
+      const dappParam = (0, _utilCrypto.isEthereumAddress)(dappAddress) ? {
+        Evm: dappAddress
+      } : {
+        Wasm: dappAddress
+      };
+      for (let i = 0; i < Math.min(numberOfUnclaimedEra, maxTx); i++) {
+        const tx = apiPromise.api.tx.dappsStaking.claimStaker(dappParam);
+        transactions.push(tx);
+      }
+    }
+    return apiPromise.api.tx.utility.batch(transactions);
+  }
+
+  /* Other actions */
+}
+exports.default = AstarNativeStakingPoolHandler;

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

@@ -0,0 +1,146 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/koni/api/staking/bonding/utils");
+var _base = _interopRequireDefault(require("@subwallet/extension-base/services/earning-service/handlers/native-staking/base"));
+var _types = require("@subwallet/extension-base/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _i18next = require("i18next");
+var _util = require("@polkadot/util");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class BaseParaNativeStakingPoolHandler extends _base.default {
+  /* Join pool action */
+
+  get defaultSubmitStep() {
+    return [{
+      name: 'Nominate collators',
+      type: _types.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 _util.BN(amount);
+    if (bnAmount.lte(_util.BN_ZERO)) {
+      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, 'Amount must be greater than 0')];
+    }
+    if (!poolInfo || !poolInfo.statistic) {
+      return Promise.resolve([new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)]);
+    }
+    const errors = [];
+    const selectedCollator = selectedValidators[0];
+    let bnTotalStake = new _util.BN(amount);
+    const bnChainMinStake = new _util.BN(poolInfo.statistic.earningThreshold.join || '0');
+    const bnCollatorMinStake = new _util.BN(selectedCollator.minBond || '0');
+    const bnMinStake = bnCollatorMinStake > bnChainMinStake ? bnCollatorMinStake : bnChainMinStake;
+    const minStakeErrorMessage = (0, _utils.getMinStakeErrorMessage)(chainInfo, bnMinStake);
+    const maxValidator = poolInfo.statistic.maxCandidatePerFarmer;
+    const maxValidatorErrorMessage = (0, _utils.getMaxValidatorErrorMessage)(chainInfo, maxValidator);
+    const existUnstakeErrorMessage = (0, _utils.getExistUnstakeErrorMessage)(chainInfo.slug, _KoniTypes.StakingType.NOMINATED, true);
+    if (!poolPosition || poolPosition.status === _types.EarningStatus.NOT_STAKING) {
+      if (!bnTotalStake.gte(bnMinStake)) {
+        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
+      }
+      return errors;
+    }
+    const {
+      bondedValidators
+    } = (0, _utils.getBondedValidators)(poolPosition.nominations);
+    const parsedSelectedCollatorAddress = (0, _utils2.reformatAddress)(selectedCollator.address, 0);
+    if (!bondedValidators.includes(parsedSelectedCollatorAddress)) {
+      // new delegation
+      if (!bnTotalStake.gte(bnMinStake)) {
+        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
+      }
+      const delegationCount = poolPosition.nominations.length + 1;
+      if (delegationCount > maxValidator) {
+        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.EXCEED_MAX_NOMINATIONS, maxValidatorErrorMessage));
+      }
+    } else {
+      let currentDelegationAmount = '0';
+      let hasUnstaking = false;
+      for (const delegation of poolPosition.nominations) {
+        if ((0, _utils2.reformatAddress)(delegation.validatorAddress, 0) === parsedSelectedCollatorAddress) {
+          currentDelegationAmount = delegation.activeStake;
+          hasUnstaking = !!delegation.hasUnstaking && delegation.hasUnstaking;
+          break;
+        }
+      }
+      bnTotalStake = bnTotalStake.add(new _util.BN(currentDelegationAmount));
+      if (!bnTotalStake.gte(bnMinStake)) {
+        errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.NOT_ENOUGH_MIN_STAKE, minStakeErrorMessage));
+      }
+      if (hasUnstaking) {
+        errors.push(new _TransactionError.TransactionError(_KoniTypes.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.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR)];
+    }
+    if (fastLeave) {
+      return [new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS)];
+    }
+    const bnAmount = new _util.BN(amount);
+    if (bnAmount.lte(_util.BN_ZERO)) {
+      errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS, (0, _i18next.t)('Amount must be greater than 0')));
+    }
+    let targetNomination;
+    for (const nomination of poolPosition.nominations) {
+      if ((0, _utils2.isSameAddress)(nomination.validatorAddress, selectedTarget)) {
+        targetNomination = nomination;
+        break;
+      }
+    }
+    if (!targetNomination) {
+      errors.push(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INTERNAL_ERROR));
+      return errors;
+    }
+    const bnActiveStake = new _util.BN(targetNomination.activeStake);
+    const bnRemainingStake = bnActiveStake.sub(new _util.BN(amount));
+    const bnChainMinStake = new _util.BN(poolInfo.statistic.earningThreshold.join || '0');
+    const bnCollatorMinStake = new _util.BN(targetNomination.validatorMinStake || '0');
+    const bnMinStake = _util.BN.max(bnCollatorMinStake, bnChainMinStake);
+    const existUnstakeErrorMessage = (0, _utils.getExistUnstakeErrorMessage)(this.chain, _KoniTypes.StakingType.NOMINATED);
+    if (targetNomination.hasUnstaking) {
+      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.EXIST_UNSTAKING_REQUEST, existUnstakeErrorMessage));
+    }
+    if (!(bnRemainingStake.isZero() || bnRemainingStake.gte(bnMinStake))) {
+      errors.push(new _TransactionError.TransactionError(_KoniTypes.StakingTxErrorType.INVALID_ACTIVE_STAKE));
+    }
+    return errors;
+  }
+
+  /* Leave pool action */
+}
+exports.default = BaseParaNativeStakingPoolHandler;