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

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

@@ -0,0 +1,434 @@
+"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 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 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(); // in blocks
+      const _blockPerRound = substrateApi.api.consts.parachainStaking.defaultBlocksPerRound.toString();
+      const maxUnstakeRequests = substrateApi.api.consts.parachainStaking.maxUnstakeRequests.toPrimitive();
+      const blockPerRound = parseFloat(_blockPerRound);
+      const roundTime = _constants._STAKING_ERA_LENGTH_MAP[this.chain] || _constants._STAKING_ERA_LENGTH_MAP.default; // in hours
+      const blockDuration = roundTime / 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 = {
+        ...this.baseInfo,
+        type: this.type,
+        metadata: {
+          ...this.metadataInfo,
+          description: this.getDescription(minToHuman)
+        },
+        statistic: {
+          assetEarning: [{
+            slug: this.nativeToken.slug
+          }],
+          maxCandidatePerFarmer: parseInt(maxDelegations),
+          maxWithdrawalRequestPerFarmer: maxUnstakeRequests,
+          // by default
+          earningThreshold: {
+            join: minDelegatorStake,
+            defaultUnstake: '0',
+            fastUnstake: '0'
+          },
+          farmerCount: delegatorStorages.length,
+          // One delegator (farmer) - One collator (candidate) - on storage
+          era: round,
+          eraTime: roundTime,
+          tvl: stakeInfo.delegators,
+          // TODO recheck
+          totalApy: undefined,
+          // TODO recheck
+          unstakingPeriod
+        }
+      };
+      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();
+    const hasUnstakingInfo = unstakingInfo && Object.values(unstakingInfo).length > 0;
+    let activeStake = '0';
+    let unstakingBalance = '0';
+    if (delegatorState) {
+      // delegatorState can be null while unstaking all
+      const identityPromises = delegatorState.map(delegate => (0, _utils2.parseIdentity)(substrateApi, delegate.owner));
+      const identities = await Promise.all(identityPromises);
+      for (let i = 0; i < delegatorState.length; i++) {
+        const delegate = delegatorState[i];
+        const [identity] = identities[i];
+        activeStake = delegate.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: delegate.owner,
+          activeStake: delegate.amount.toString(),
+          validatorMinStake: '0',
+          hasUnstaking: hasUnstakingInfo,
+          validatorIdentity: identity
+        });
+      }
+      if (hasUnstakingInfo) {
+        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);
+        for (const [unstakingBlock, unstakingAmount] of Object.entries(unstakingInfo)) {
+          const blockDuration = (_constants._STAKING_ERA_LENGTH_MAP[chainInfo.slug] || _constants._STAKING_ERA_LENGTH_MAP.default) / blockPerRound; // in hours
+
+          const isClaimable = parseInt(unstakingBlock) - currentBlockNumber < 0;
+          const remainingBlock = parseInt(unstakingBlock) - currentBlockNumber;
+          const waitingTime = remainingBlock * blockDuration;
+          unstakingBalance = unstakingAmount.toString();
+          unstakingList.push({
+            chain: chainInfo.slug,
+            status: isClaimable ? _types.UnstakingStatus.CLAIMABLE : _types.UnstakingStatus.UNLOCKING,
+            claimable: unstakingAmount.toString(),
+            waitingTime,
+            validatorAddress: 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.baseInfo;
+    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);
+          let delegatorState = [];
+          const unstakingInfo = _unstakingStates[i].toPrimitive();
+          if (_constants2._STAKING_CHAIN_GROUP.krest_network.includes(this.chain)) {
+            const krestDelegatorState = _delegatorState.toPrimitive();
+            const delegates = krestDelegatorState === null || krestDelegatorState === void 0 ? void 0 : krestDelegatorState.delegations;
+            if (delegates) {
+              delegatorState = delegatorState.concat(delegates);
+            }
+          } else {
+            const delegate = _delegatorState.toPrimitive();
+            if (delegate) {
+              delegatorState.push(delegate);
+            }
+          }
+          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) && !_constants2._STAKING_CHAIN_GROUP.krest_network.includes(this.chain)) {
+      await Promise.all(useAddresses.map(async address => {
+        const _unclaimedReward = await substrateApi.api.query.parachainStaking.rewards(address);
+        if (cancel) {
+          return;
+        }
+        callBack({
+          ...this.baseInfo,
+          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;
+    if (_constants2._STAKING_CHAIN_GROUP.krest_network.includes(this.chain)) {
+      const _allCollators = await chainApi.api.query.parachainStaking.candidatePool.entries();
+      const maxDelegatorsPerCollator = chainApi.api.consts.parachainStaking.maxDelegatorsPerCollator.toString();
+      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,
+          blocked: false,
+          isVerified: false,
+          minBond: '0',
+          chain: this.chain,
+          isCrowded: collatorInfo.delegators.length >= parseInt(maxDelegatorsPerCollator)
+        });
+      }
+      return allCollators;
+    } else {
+      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];
+
+    // eslint-disable-next-line @typescript-eslint/require-await
+    const compoundResult = async extrinsic => {
+      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'
+      }];
+    };
+    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;