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

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

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "AmplitudeNativeStakingPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _amplitude.default;
+  }
+});
+Object.defineProperty(exports, "AstarNativeStakingPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _astar.default;
+  }
+});
+Object.defineProperty(exports, "ParaNativeStakingPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _paraChain.default;
+  }
+});
+Object.defineProperty(exports, "RelayNativeStakingPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _relayChain.default;
+  }
+});
+var _amplitude = _interopRequireDefault(require("./amplitude"));
+var _astar = _interopRequireDefault(require("./astar"));
+var _relayChain = _interopRequireDefault(require("./relay-chain"));
+var _paraChain = _interopRequireDefault(require("./para-chain"));

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

@@ -0,0 +1,361 @@
+"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 _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 ParaNativeStakingPoolHandler extends _basePara.default {
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    let cancel = false;
+    const chainApi = this.substrateApi;
+    const nativeToken = this.nativeToken;
+    const defaultData = this.defaultInfo;
+    await chainApi.isReady;
+    const unsub = await chainApi.api.query.parachainStaking.round(async _round => {
+      var _chainApi$api$consts, _chainApi$api$consts$, _chainApi$api$consts$2;
+      if (cancel) {
+        unsub();
+        return;
+      }
+      const roundObj = _round.toHuman();
+      const round = (0, _utils3.parseRawNumber)(roundObj.current);
+      const maxDelegations = (_chainApi$api$consts = chainApi.api.consts) === null || _chainApi$api$consts === void 0 ? void 0 : (_chainApi$api$consts$ = _chainApi$api$consts.parachainStaking) === null || _chainApi$api$consts$ === void 0 ? void 0 : (_chainApi$api$consts$2 = _chainApi$api$consts$.maxDelegationsPerDelegator) === null || _chainApi$api$consts$2 === void 0 ? void 0 : _chainApi$api$consts$2.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 _util.BN(rawUnvestedAllocation);
+      }
+      const totalStake = _totalStake ? new _util.BN(_totalStake.toString()) : _util.BN_ZERO;
+      const totalIssuance = new _util.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 = (0, _utils.getParaCurrentInflation)((0, _utils3.parseRawNumber)(totalStake.toString()), inflationConfig);
+      const unstakingPeriod = parseInt(unstakingDelay) * (_constants._STAKING_ERA_LENGTH_MAP[this.chain] || _constants._STAKING_ERA_LENGTH_MAP.default);
+      const minStake = '0';
+      const minToHuman = (0, _utils3.formatNumber)(minStake.toString(), nativeToken.decimals || 0, _utils3.balanceFormatter);
+      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: minStake.toString(),
+          farmerCount: 0,
+          // TODO recheck
+          era: round,
+          totalApy: undefined,
+          // not have
+          tvl: totalStake.toString(),
+          unstakingPeriod: unstakingPeriod,
+          allowCancelUnstaking: true,
+          inflation
+        }
+      };
+      callback(data);
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool info */
+
+  /* Subscribe pool position */
+
+  async parseNominatorMetadata(chainInfo, address, substrateApi, delegatorState) {
+    const nominationList = [];
+    const unstakingMap = {};
+    let bnTotalActiveStake = _util.BN_ZERO;
+    let bnTotalStake = _util.BN_ZERO;
+    let bnTotalUnstaking = _util.BN_ZERO;
+    const _roundInfo = await substrateApi.api.query.parachainStaking.round();
+    const roundInfo = _roundInfo.toPrimitive();
+    const currentRound = roundInfo.current;
+    await Promise.all(delegatorState.delegations.map(async delegation => {
+      const [_delegationScheduledRequests, [identity], _collatorInfo] = await Promise.all([substrateApi.api.query.parachainStaking.delegationScheduledRequests(delegation.owner), (0, _utils2.parseIdentity)(substrateApi, delegation.owner), substrateApi.api.query.parachainStaking.candidateInfo(delegation.owner)]);
+      const collatorInfo = _collatorInfo.toPrimitive();
+      const minDelegation = collatorInfo === null || collatorInfo === void 0 ? void 0 : collatorInfo.lowestTopDelegationAmount.toString();
+      const delegationScheduledRequests = _delegationScheduledRequests.toPrimitive();
+      let hasUnstaking = false;
+      let delegationStatus = _types.EarningStatus.NOT_EARNING;
+
+      // parse unstaking info
+      if (delegationScheduledRequests) {
+        for (const scheduledRequest of delegationScheduledRequests) {
+          if ((0, _utils3.reformatAddress)(scheduledRequest.delegator, 0) === (0, _utils3.reformatAddress)(address, 0)) {
+            // add network prefix
+            const isClaimable = scheduledRequest.whenExecutable - currentRound < 0;
+            const remainingEra = scheduledRequest.whenExecutable - currentRound;
+            const waitingTime = remainingEra * _constants._STAKING_ERA_LENGTH_MAP[chainInfo.slug];
+            const claimable = Object.values(scheduledRequest.action)[0];
+            unstakingMap[delegation.owner] = {
+              chain: chainInfo.slug,
+              status: isClaimable ? _types.UnstakingStatus.CLAIMABLE : _types.UnstakingStatus.UNLOCKING,
+              validatorAddress: delegation.owner,
+              claimable: claimable.toString(),
+              waitingTime
+            };
+            hasUnstaking = true;
+            break; // only handle 1 scheduledRequest per collator
+          }
+        }
+      }
+
+      const bnStake = new _util.BN(delegation.amount);
+      const bnUnstakeBalance = unstakingMap[delegation.owner] ? new _util.BN(unstakingMap[delegation.owner].claimable) : _util.BN_ZERO;
+      const bnActiveStake = bnStake.sub(bnUnstakeBalance);
+      if (bnActiveStake.gt(_util.BN_ZERO) && bnActiveStake.gte(new _util.BN(minDelegation))) {
+        delegationStatus = _types.EarningStatus.EARNING_REWARD;
+      }
+      bnTotalActiveStake = bnTotalActiveStake.add(bnActiveStake);
+      bnTotalStake = bnTotalStake.add(bnStake);
+      bnTotalUnstaking = bnTotalUnstaking.add(bnUnstakeBalance);
+      nominationList.push({
+        chain: chainInfo.slug,
+        status: delegationStatus,
+        validatorAddress: delegation.owner,
+        validatorIdentity: identity,
+        activeStake: bnActiveStake.toString(),
+        hasUnstaking,
+        validatorMinStake: collatorInfo.lowestTopDelegationAmount.toString()
+      });
+    }));
+
+    // await Promise.all(nominationList.map(async (nomination) => {
+    //   const _collatorInfo = await substrateApi.api.query.parachainStaking.candidateInfo(nomination.validatorAddress);
+    //   const collatorInfo = _collatorInfo.toPrimitive() as unknown as ParachainStakingCandidateMetadata;
+    //
+    //   nomination.validatorMinStake = collatorInfo.lowestTopDelegationAmount.toString();
+    // }));
+
+    const stakingStatus = (0, _utils.getEarningStatusByNominations)(bnTotalActiveStake, nominationList);
+    const totalStake = bnTotalStake.toString();
+    const activeStake = bnTotalActiveStake.toString();
+    const unstakingBalance = bnTotalUnstaking.toString();
+    return {
+      status: stakingStatus,
+      totalStake,
+      balanceToken: this.nativeToken.slug,
+      activeStake: activeStake,
+      unstakeBalance: unstakingBalance,
+      isBondedBefore: !!nominationList.length,
+      nominations: nominationList,
+      unstakings: Object.values(unstakingMap)
+    };
+  }
+  async subscribePoolPosition(useAddresses, resultCallback) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    const defaultInfo = this.defaultInfo;
+    const chainInfo = this.chainInfo;
+    await substrateApi.isReady;
+    const unsub = await substrateApi.api.query.parachainStaking.delegatorState.multi(useAddresses, async ledgers => {
+      if (cancel) {
+        unsub();
+        return;
+      }
+      if (ledgers) {
+        await Promise.all(ledgers.map(async (_delegatorState, i) => {
+          const delegatorState = _delegatorState.toPrimitive();
+          const owner = (0, _utils3.reformatAddress)(useAddresses[i], 42);
+          if (delegatorState) {
+            const nominatorMetadata = await this.parseNominatorMetadata(chainInfo, owner, substrateApi, delegatorState);
+            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',
+              status: _types.EarningStatus.NOT_STAKING,
+              isBondedBefore: false,
+              nominations: [],
+              unstakings: []
+            });
+          }
+        }));
+      }
+    });
+    return () => {
+      cancel = true;
+      unsub();
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Get pool targets */
+
+  async getPoolTargets() {
+    const apiProps = await this.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();
+      const bnTotalStake = new _util.BN(collatorInfo.totalCounted);
+      const bnOwnStake = new _util.BN(collatorInfo.bond);
+      const bnOtherStake = bnTotalStake.sub(bnOwnStake);
+      const bnMinBond = new _util.BN(collatorInfo.lowestTopDelegationAmount);
+      allCollators.push({
+        commission: 0,
+        expectedReturn: 0,
+        address: collatorAddress,
+        totalStake: bnTotalStake.toString(),
+        ownStake: bnOwnStake.toString(),
+        otherStake: bnOtherStake.toString(),
+        nominatorCount: collatorInfo.delegationCount,
+        blocked: false,
+        isVerified: false,
+        minBond: bnMinBond.toString(),
+        chain: this.chain,
+        isCrowded: parseInt(maxDelegationPerCollator) > 0
+      });
+    }
+    const extraInfoMap = {};
+    await Promise.all(allCollators.map(async collator => {
+      const [_info, [identity, isReasonable]] = await Promise.all([apiProps.api.query.parachainStaking.candidateInfo(collator.address), (0, _utils2.parseIdentity)(apiProps, collator.address)]);
+      const rawInfo = _info.toHuman();
+      const active = (rawInfo === null || rawInfo === void 0 ? void 0 : rawInfo.status) === 'Active';
+      extraInfoMap[collator.address] = {
+        identity,
+        isVerified: isReasonable,
+        active
+      };
+    }));
+    for (const validator of allCollators) {
+      validator.blocked = !extraInfoMap[validator.address].active;
+      validator.identity = extraInfoMap[validator.address].identity;
+      validator.isVerified = extraInfoMap[validator.address].isVerified;
+      // @ts-ignore
+      validator.commission = collatorCommission;
+    }
+    return allCollators;
+  }
+
+  /* Get pool targets */
+
+  /* Join pool action */
+
+  async createJoinExtrinsic(data, positionInfo) {
+    const {
+      address,
+      amount,
+      selectedValidators
+    } = data;
+    const apiPromise = await this.substrateApi.isReady;
+    const binaryAmount = new _util.BN(amount);
+    const selectedCollatorInfo = selectedValidators[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 (!positionInfo) {
+      const extrinsic = apiPromise.api.tx.parachainStaking.delegate(selectedCollatorInfo.address, binaryAmount, new _util.BN(selectedCollatorInfo.nominatorCount), 0);
+      return compoundResult(extrinsic);
+    }
+    const {
+      bondedValidators,
+      nominationCount
+    } = (0, _utils.getBondedValidators)(positionInfo.nominations);
+    const parsedSelectedCollatorAddress = (0, _utils3.reformatAddress)(selectedCollatorInfo.address, 0);
+    if (!bondedValidators.includes(parsedSelectedCollatorAddress)) {
+      const extrinsic = apiPromise.api.tx.parachainStaking.delegate(selectedCollatorInfo.address, binaryAmount, new _util.BN(selectedCollatorInfo.nominatorCount), nominationCount);
+      return compoundResult(extrinsic);
+    } else {
+      const extrinsic = apiPromise.api.tx.parachainStaking.delegatorBondMore(selectedCollatorInfo.address, binaryAmount);
+      return compoundResult(extrinsic);
+    }
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const apiPromise = 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) {
+      extrinsic = apiPromise.api.tx.parachainStaking.scheduleDelegatorBondLess(selectedTarget, binaryAmount);
+    } else {
+      extrinsic = apiPromise.api.tx.parachainStaking.scheduleRevokeDelegation(selectedTarget);
+    }
+    return [_KoniTypes.ExtrinsicType.STAKING_LEAVE_POOL, extrinsic];
+  }
+
+  /* Leave pool action */
+
+  /* Other action */
+
+  async handleYieldCancelUnstake(params) {
+    const {
+      selectedUnstaking
+    } = params;
+    const chainApi = await this.substrateApi.isReady;
+    return chainApi.api.tx.parachainStaking.cancelDelegationRequest(selectedUnstaking.validatorAddress);
+  }
+  async handleYieldWithdraw(address, unstakingInfo) {
+    const collatorAddress = unstakingInfo.validatorAddress;
+    if (!collatorAddress) {
+      return Promise.reject(new _TransactionError.TransactionError(_KoniTypes.BasicTxErrorType.INVALID_PARAMS));
+    }
+    const chainApi = await this.substrateApi.isReady;
+    return chainApi.api.tx.parachainStaking.executeDelegationRequest(address, collatorAddress);
+  }
+
+  /* Other actions */
+}
+exports.default = ParaNativeStakingPoolHandler;