@subwallet/extension-base 1.1.28-0 → 1.1.28-beta.1

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

@@ -0,0 +1,359 @@
+"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 _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _constants2 = require("@subwallet/extension-base/services/earning-service/constants");
+var _utils2 = require("@subwallet/extension-base/services/earning-service/utils");
+var _types = require("@subwallet/extension-base/types");
+var _utils3 = require("@subwallet/extension-base/utils");
+var _util = require("@polkadot/util");
+var _basePara = _interopRequireDefault(require("./base-para"));
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+class AmplitudeNativeStakingPoolHandler extends _basePara.default {
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    let cancel = false;
+    const nativeToken = this.nativeToken;
+    const defaultData = this.defaultInfo;
+    const substrateApi = await this.substrateApi.isReady;
+    const unsub = await substrateApi.api.query.parachainStaking.round(async _round => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      const roundObj = _round.toHuman();
+      const round = (0, _utils3.parseRawNumber)(roundObj.current);
+      const maxDelegations = substrateApi.api.consts.parachainStaking.maxDelegationsPerRound.toString();
+      const minDelegatorStake = substrateApi.api.consts.parachainStaking.minDelegatorStake.toString();
+      const unstakingDelay = substrateApi.api.consts.parachainStaking.stakeDuration.toString();
+      const _blockPerRound = substrateApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
+      const blockPerRound = parseFloat(_blockPerRound);
+      const blockDuration = (_constants._STAKING_ERA_LENGTH_MAP[this.chain] || _constants._STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
+      const unstakingPeriod = blockDuration * parseInt(unstakingDelay);
+      const minToHuman = (0, _utils3.formatNumber)(minDelegatorStake, nativeToken.decimals || 0, _utils3.balanceFormatter);
+      const delegatorStorages = await substrateApi.api.query.parachainStaking.delegatorState.keys();
+      const staked = await substrateApi.api.query.parachainStaking.totalCollatorStake();
+      const stakeInfo = staked.toPrimitive();
+      const data = {
+        // TODO
+        ...defaultData,
+        description: this.description.replaceAll('{{amount}}', minToHuman),
+        type: this.type,
+        metadata: {
+          inputAsset: nativeToken.slug,
+          isAvailable: true,
+          maxCandidatePerFarmer: parseInt(maxDelegations),
+          maxWithdrawalRequestPerFarmer: 1,
+          // by default
+          minJoinPool: minDelegatorStake,
+          farmerCount: delegatorStorages.length,
+          // One delegator (farmer) - One collator (candidate) - on storage
+          era: round,
+          tvl: stakeInfo.delegators,
+          // TODO recheck
+          totalApy: undefined,
+          // TODO recheck
+          unstakingPeriod,
+          allowCancelUnstaking: true
+        }
+      };
+      callback(data);
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool position */
+
+  async parseNominatorMetadata(chainInfo, address, substrateApi, delegatorState, unstakingInfo) {
+    const nominationList = [];
+    const unstakingList = [];
+    const minDelegatorStake = substrateApi.api.consts.parachainStaking.minDelegatorStake.toString();
+    let activeStake = '0';
+    let unstakingBalance = '0';
+    if (delegatorState) {
+      // delegatorState can be null while unstaking all
+      const [identity] = await (0, _utils2.parseIdentity)(substrateApi, delegatorState.owner);
+      activeStake = delegatorState.amount.toString();
+      const bnActiveStake = new _util.BN(activeStake);
+      let delegationStatus = _types.EarningStatus.NOT_EARNING;
+      if (bnActiveStake.gt(_util.BN_ZERO) && bnActiveStake.gte(new _util.BN(minDelegatorStake))) {
+        delegationStatus = _types.EarningStatus.EARNING_REWARD;
+      }
+      nominationList.push({
+        status: delegationStatus,
+        chain: chainInfo.slug,
+        validatorAddress: delegatorState.owner,
+        activeStake: delegatorState.amount.toString(),
+        validatorMinStake: '0',
+        hasUnstaking: !!unstakingInfo && Object.values(unstakingInfo).length > 0,
+        validatorIdentity: identity
+      });
+    }
+    if (unstakingInfo && Object.values(unstakingInfo).length > 0) {
+      const _currentBlockInfo = await substrateApi.api.rpc.chain.getHeader();
+      const currentBlockInfo = _currentBlockInfo.toPrimitive();
+      const currentBlockNumber = currentBlockInfo.number;
+      const _blockPerRound = substrateApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
+      const blockPerRound = parseFloat(_blockPerRound);
+      const nearestUnstakingBlock = Object.keys(unstakingInfo)[0];
+      const nearestUnstakingAmount = Object.values(unstakingInfo)[0];
+      const blockDuration = (_constants._STAKING_ERA_LENGTH_MAP[chainInfo.slug] || _constants._STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
+
+      const isClaimable = parseInt(nearestUnstakingBlock) - currentBlockNumber < 0;
+      const remainingBlock = parseInt(nearestUnstakingBlock) - currentBlockNumber;
+      const waitingTime = remainingBlock * blockDuration;
+      unstakingBalance = nearestUnstakingAmount.toString();
+      unstakingList.push({
+        chain: chainInfo.slug,
+        status: isClaimable ? _types.UnstakingStatus.CLAIMABLE : _types.UnstakingStatus.UNLOCKING,
+        claimable: nearestUnstakingAmount.toString(),
+        waitingTime,
+        validatorAddress: (delegatorState === null || delegatorState === void 0 ? void 0 : delegatorState.owner) || undefined
+      });
+    }
+    const totalBalance = new _util.BN(activeStake).add(new _util.BN(unstakingBalance));
+    const stakingStatus = (0, _utils.getEarningStatusByNominations)(new _util.BN(activeStake), nominationList);
+    return {
+      status: stakingStatus,
+      balanceToken: this.nativeToken.slug,
+      totalStake: totalBalance.toString(),
+      activeStake: activeStake,
+      unstakeBalance: unstakingBalance,
+      isBondedBefore: true,
+      nominations: nominationList,
+      unstakings: unstakingList
+    };
+  }
+  async subscribePoolPosition(useAddresses, resultCallback) {
+    let cancel = false;
+    const substrateApi = await this.substrateApi.isReady;
+    const defaultInfo = this.defaultInfo;
+    const chainInfo = this.chainInfo;
+    const unsub = await substrateApi.api.query.parachainStaking.delegatorState.multi(useAddresses, async ledgers => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      if (ledgers) {
+        const _unstakingStates = await substrateApi.api.query.parachainStaking.unstaking.multi(useAddresses);
+        await Promise.all(ledgers.map(async (_delegatorState, i) => {
+          const owner = (0, _utils3.reformatAddress)(useAddresses[i], 42);
+          const delegatorState = _delegatorState.toPrimitive();
+          const unstakingInfo = _unstakingStates[i].toPrimitive();
+          if (!delegatorState && !unstakingInfo) {
+            resultCallback({
+              ...defaultInfo,
+              type: this.type,
+              address: owner,
+              balanceToken: this.nativeToken.slug,
+              totalStake: '0',
+              activeStake: '0',
+              unstakeBalance: '0',
+              status: _types.EarningStatus.NOT_STAKING,
+              isBondedBefore: false,
+              nominations: [],
+              unstakings: []
+            });
+          } else {
+            const nominatorMetadata = await this.parseNominatorMetadata(chainInfo, owner, substrateApi, delegatorState, unstakingInfo);
+            resultCallback({
+              ...defaultInfo,
+              ...nominatorMetadata,
+              address: owner,
+              type: this.type
+            });
+          }
+        }));
+      }
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Get pool reward */
+
+  async getPoolReward(useAddresses, callBack) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    await substrateApi.isReady;
+    if (!_constants2._STAKING_CHAIN_GROUP.kilt.includes(this.chain)) {
+      await Promise.all(useAddresses.map(async address => {
+        const _unclaimedReward = await substrateApi.api.query.parachainStaking.rewards(address);
+        if (cancel) {
+          return;
+        }
+        callBack({
+          ...this.defaultInfo,
+          address: address,
+          type: this.type,
+          unclaimedReward: _unclaimedReward.toString(),
+          state: _KoniTypes.APIItemState.READY
+        });
+      }));
+    }
+    return () => {
+      cancel = false;
+    };
+  }
+
+  /* Get pool reward */
+
+  /* Get pool targets */
+
+  async getPoolTargets() {
+    const chainApi = await this.substrateApi.isReady;
+    const [_allCollators, _inflationConfig] = await Promise.all([chainApi.api.query.parachainStaking.candidatePool.entries(), chainApi.api.query.parachainStaking.inflationConfig()]);
+    const maxDelegatorsPerCollator = chainApi.api.consts.parachainStaking.maxDelegatorsPerCollator.toString();
+    const inflationConfig = _inflationConfig.toHuman();
+    const rawDelegatorReturn = inflationConfig.delegator.rewardRate.annual;
+    const delegatorReturn = parseFloat(rawDelegatorReturn.split('%')[0]);
+    const allCollators = [];
+    for (const _collator of _allCollators) {
+      const collatorInfo = _collator[1].toPrimitive();
+      const bnTotalStake = new _util.BN(collatorInfo.total);
+      const bnOwnStake = new _util.BN(collatorInfo.stake);
+      const bnOtherStake = bnTotalStake.sub(bnOwnStake);
+      allCollators.push({
+        address: collatorInfo.id,
+        totalStake: bnTotalStake.toString(),
+        ownStake: bnOwnStake.toString(),
+        otherStake: bnOtherStake.toString(),
+        nominatorCount: collatorInfo.delegators.length,
+        commission: 0,
+        expectedReturn: delegatorReturn,
+        blocked: false,
+        isVerified: false,
+        minBond: '0',
+        chain: this.chain,
+        isCrowded: collatorInfo.delegators.length >= parseInt(maxDelegatorsPerCollator)
+      });
+    }
+    return allCollators;
+  }
+
+  /* Get pool targets */
+
+  /* Join pool action */
+
+  get defaultSubmitStep() {
+    return [{
+      name: 'Nominate collators',
+      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 {
+      address,
+      amount,
+      selectedValidators: targetValidators
+    } = data;
+    const chainApi = await this.substrateApi.isReady;
+    const binaryAmount = new _util.BN(amount);
+    const poolPosition = await this.getPoolPosition(address);
+    const selectedValidatorInfo = targetValidators[0];
+    const compoundResult = async extrinsic => {
+      const tokenSlug = this.nativeToken.slug;
+      const feeInfo = await extrinsic.paymentInfo(address);
+      const fee = feeInfo.toPrimitive();
+      return [extrinsic, {
+        slug: tokenSlug,
+        amount: fee.partialFee.toString()
+      }];
+    };
+    if (!poolPosition) {
+      const extrinsic = chainApi.api.tx.parachainStaking.joinDelegators(selectedValidatorInfo.address, binaryAmount);
+      return compoundResult(extrinsic);
+    }
+    const {
+      bondedValidators
+    } = (0, _utils.getBondedValidators)(poolPosition.nominations);
+    if (!bondedValidators.includes((0, _utils3.reformatAddress)(selectedValidatorInfo.address, 0))) {
+      const extrinsic = chainApi.api.tx.parachainStaking.joinDelegators(selectedValidatorInfo.address, binaryAmount);
+      return compoundResult(extrinsic);
+    } else {
+      const _params = chainApi.api.tx.parachainStaking.delegatorStakeMore.toJSON();
+      const paramsCount = _params.args.length;
+      if (paramsCount === 2) {
+        // detect number of params
+        const extrinsic = chainApi.api.tx.parachainStaking.delegatorStakeMore(selectedValidatorInfo.address, binaryAmount);
+        return compoundResult(extrinsic);
+      } else {
+        const extrinsic = chainApi.api.tx.parachainStaking.delegatorStakeMore(binaryAmount);
+        return compoundResult(extrinsic);
+      }
+    }
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const chainApi = await this.substrateApi.isReady;
+    const binaryAmount = new _util.BN(amount);
+    const poolPosition = await this.getPoolPosition(address);
+    if (!selectedTarget || !poolPosition) {
+      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS));
+    }
+    const unstakeAll = (0, _utils.isUnstakeAll)(selectedTarget, poolPosition.nominations, amount);
+    let extrinsic;
+    if (!unstakeAll) {
+      const _params = chainApi.api.tx.parachainStaking.delegatorStakeMore.toJSON();
+      const paramsCount = _params.args.length;
+      if (paramsCount === 2) {
+        extrinsic = chainApi.api.tx.parachainStaking.delegatorStakeLess(selectedTarget, binaryAmount);
+      } else {
+        extrinsic = chainApi.api.tx.parachainStaking.delegatorStakeLess(binaryAmount);
+      }
+    } else {
+      extrinsic = chainApi.api.tx.parachainStaking.leaveDelegators();
+    }
+    return [_KoniTypes.ExtrinsicType.STAKING_LEAVE_POOL, extrinsic];
+  }
+
+  /* Leave pool action */
+
+  /* Other action */
+
+  /**
+   * @todo Need recheck
+   * */
+  async handleYieldCancelUnstake(params) {
+    const chainApi = await this.substrateApi.isReady;
+    return chainApi.api.tx.parachainStaking.cancelLeaveCandidates();
+  }
+  async handleYieldWithdraw(address, unstakingInfo) {
+    const chainApi = await this.substrateApi.isReady;
+    return chainApi.api.tx.parachainStaking.unlockUnstaked(address);
+  }
+  async handleYieldClaimReward(address, bondReward) {
+    const chainApi = await this.substrateApi.isReady;
+    return chainApi.api.tx.utility.batch([chainApi.api.tx.parachainStaking.incrementDelegatorRewards(), chainApi.api.tx.parachainStaking.claimRewards()]);
+  }
+
+  /* Other actions */
+}
+exports.default = AmplitudeNativeStakingPoolHandler;