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

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

@@ -0,0 +1,375 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { APIItemState, BasicTxErrorType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { getBondedValidators, getEarningStatusByNominations, isUnstakeAll } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
+import { _STAKING_CHAIN_GROUP } from '@subwallet/extension-base/services/earning-service/constants';
+import { parseIdentity } from '@subwallet/extension-base/services/earning-service/utils';
+import { EarningStatus, UnstakingStatus, YieldStepType } from '@subwallet/extension-base/types';
+import { balanceFormatter, formatNumber, parseRawNumber, reformatAddress } from '@subwallet/extension-base/utils';
+import { BN, BN_ZERO } from '@polkadot/util';
+import BaseParaNativeStakingPoolHandler from "./base-para.js";
+export default class AmplitudeNativeStakingPoolHandler extends BaseParaNativeStakingPoolHandler {
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    let cancel = false;
+    const nativeToken = this.nativeToken;
+    if (!this.isActive) {
+      const data = {
+        ...this.baseInfo,
+        type: this.type,
+        metadata: {
+          ...this.metadataInfo,
+          description: this.getDescription()
+        }
+      };
+      callback(data);
+      return () => {
+        cancel = true;
+      };
+    }
+    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 = 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 blockPerRound = parseFloat(_blockPerRound);
+      const roundTime = _STAKING_ERA_LENGTH_MAP[this.chain] || _STAKING_ERA_LENGTH_MAP.default; // in hours
+      const blockDuration = roundTime / blockPerRound; // in hours
+      const unstakingPeriod = blockDuration * parseInt(unstakingDelay);
+      const minToHuman = formatNumber(minDelegatorStake, nativeToken.decimals || 0, 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: 1,
+          // 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();
+    let activeStake = '0';
+    let unstakingBalance = '0';
+    if (delegatorState) {
+      // delegatorState can be null while unstaking all
+      const [identity] = await parseIdentity(substrateApi, delegatorState.owner);
+      activeStake = delegatorState.amount.toString();
+      const bnActiveStake = new BN(activeStake);
+      let delegationStatus = EarningStatus.NOT_EARNING;
+      if (bnActiveStake.gt(BN_ZERO) && bnActiveStake.gte(new BN(minDelegatorStake))) {
+        delegationStatus = 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 = (_STAKING_ERA_LENGTH_MAP[chainInfo.slug] || _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 ? UnstakingStatus.CLAIMABLE : UnstakingStatus.UNLOCKING,
+        claimable: nearestUnstakingAmount.toString(),
+        waitingTime,
+        validatorAddress: (delegatorState === null || delegatorState === void 0 ? void 0 : delegatorState.owner) || undefined
+      });
+    }
+    const totalBalance = new BN(activeStake).add(new BN(unstakingBalance));
+    const stakingStatus = getEarningStatusByNominations(new 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 = 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: 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 (!_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.baseInfo,
+          address: address,
+          type: this.type,
+          unclaimedReward: _unclaimedReward.toString(),
+          state: 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 BN(collatorInfo.total);
+      const bnOwnStake = new 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: YieldStepType.NOMINATE
+    }, {
+      slug: this.nativeToken.slug,
+      amount: '0'
+    }];
+  }
+  async createJoinExtrinsic(data, positionInfo, bondDest = 'Staked') {
+    const {
+      address,
+      amount,
+      selectedValidators: targetValidators
+    } = data;
+    const chainApi = await this.substrateApi.isReady;
+    const binaryAmount = new 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
+    } = getBondedValidators(poolPosition.nominations);
+    if (!bondedValidators.includes(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 BN(amount);
+    const poolPosition = await this.getPoolPosition(address);
+    if (!selectedTarget || !poolPosition) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
+    }
+    const unstakeAll = 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 [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 */
+}

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

@@ -0,0 +1,19 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ExtrinsicType, UnstakingInfo } from '@subwallet/extension-base/background/KoniTypes';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import { BaseYieldPositionInfo, PalletDappsStakingAccountLedger, StakeCancelWithdrawalParams, SubmitJoinNativeStaking, TransactionData, ValidatorInfo, YieldPoolInfo, YieldPoolMethodInfo, YieldPositionInfo, YieldStepBaseInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import BaseParaNativeStakingPoolHandler from './base-para';
+export declare function getAstarWithdrawable(yieldPosition: YieldPositionInfo): UnstakingInfo | undefined;
+export default class AstarNativeStakingPoolHandler extends BaseParaNativeStakingPoolHandler {
+    protected readonly availableMethod: YieldPoolMethodInfo;
+    subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
+    parseNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi, ledger: PalletDappsStakingAccountLedger): Promise<Omit<YieldPositionInfo, keyof BaseYieldPositionInfo>>;
+    subscribePoolPosition(useAddresses: string[], resultCallback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
+    getPoolTargets(): Promise<ValidatorInfo[]>;
+    get defaultSubmitStep(): YieldStepBaseInfo;
+    createJoinExtrinsic(data: SubmitJoinNativeStaking, positionInfo?: YieldPositionInfo, bondDest?: string): Promise<[TransactionData, YieldTokenBaseInfo]>;
+    handleYieldUnstake(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+    handleYieldCancelUnstake(params: StakeCancelWithdrawalParams): Promise<TransactionData>;
+    handleYieldWithdraw(address: string, unstakingInfo: UnstakingInfo): Promise<TransactionData>;
+    handleYieldClaimReward(address: string, bondReward?: boolean): Promise<import("@polkadot/api-base/types").SubmittableExtrinsic<"promise", import("@polkadot/types/types").ISubmittableResult>>;
+}