@subwallet/extension-base 1.3.24-0 → 1.3.26-0

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

@@ -0,0 +1,444 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTaoToAlphaMapping = exports.default = void 0;
+var _TransactionError = require("@subwallet/extension-base/background/errors/TransactionError");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _constants = require("@subwallet/extension-base/constants");
+var _utils = require("@subwallet/extension-base/koni/api/staking/bonding/utils");
+var _basePara = _interopRequireDefault(require("@subwallet/extension-base/services/earning-service/handlers/native-staking/base-para"));
+var _types = require("@subwallet/extension-base/types");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _util = require("@polkadot/util");
+var _utils3 = require("../../utils");
+var _tao = require("./tao");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+const getTaoToAlphaMapping = async substrateApi => {
+  const allSubnets = (await substrateApi.api.call.subnetInfoRuntimeApi.getAllDynamicInfo()).toJSON();
+  if (!allSubnets) {
+    return {};
+  }
+  return allSubnets.reduce((acc, subnet) => {
+    const netuid = subnet === null || subnet === void 0 ? void 0 : subnet.netuid;
+    const taoIn = subnet !== null && subnet !== void 0 && subnet.taoIn ? new _bignumber.default(subnet.taoIn) : new _bignumber.default(0);
+    const alphaIn = subnet !== null && subnet !== void 0 && subnet.alphaIn ? new _bignumber.default(subnet.alphaIn) : new _bignumber.default(0);
+    if (netuid === 0) {
+      acc[netuid] = '1';
+    } else if (alphaIn.gt(0)) {
+      acc[netuid] = taoIn.dividedBy(alphaIn).toString();
+    } else {
+      acc[netuid] = '1';
+    }
+    return acc;
+  }, {});
+};
+exports.getTaoToAlphaMapping = getTaoToAlphaMapping;
+class SubnetTaoStakingPoolHandler extends _basePara.default {
+  /* Unimplemented function  */
+  handleYieldWithdraw(address, unstakingInfo) {
+    throw new Error('Method not implemented.');
+  }
+  handleYieldCancelUnstake(params) {
+    throw new Error('Method not implemented.');
+  }
+  /* Unimplemented function  */
+
+  // @ts-ignore
+  type = _types.YieldPoolType.SUBNET_STAKING;
+  subnetData = [];
+  isInit = false;
+  availableMethod = {
+    join: true,
+    defaultUnstake: true,
+    fastUnstake: false,
+    cancelUnstake: false,
+    withdraw: false,
+    claimReward: false
+  };
+  constructor(state, chain) {
+    super(state, chain);
+    const _chainAsset = this.nativeToken;
+    const _chainInfo = this.chainInfo;
+    const symbol = _chainAsset.symbol;
+    this.slug = this.slug = `${symbol}___subnet_staking___${_chainInfo.slug}`;
+    this.name = 'Subnet Tao Staking';
+    this.shortName = 'dTAO Staking';
+    this.bittensorCache = _tao.BittensorCache.getInstance();
+  }
+  canHandleSlug(slug) {
+    return slug.startsWith(`${this.slug}__`);
+  }
+  get maintainBalance() {
+    const ed = new _util.BN(this.nativeToken.minAmount || '0');
+    const calculateMaintainBalance = new _util.BN(15).mul(ed).div(_util.BN_TEN);
+    const maintainBalance = calculateMaintainBalance;
+    return maintainBalance.toString();
+  }
+  async init() {
+    try {
+      const substrateApi = await this.substrateApi.isReady;
+      const dynamicInfo = (await substrateApi.api.call.subnetInfoRuntimeApi.getAllDynamicInfo()).toJSON();
+      const subnetsInfo = (await substrateApi.api.call.subnetInfoRuntimeApi.getSubnetsInfoV2()).toJSON();
+      if (dynamicInfo && subnetsInfo) {
+        const mergedData = dynamicInfo.filter(dynInfo => dynInfo.netuid !== 0).map(dynInfo => {
+          var _dynInfo$subnetIdenti, _dynInfo$subnetIdenti2;
+          const extraInfo = subnetsInfo.find(subnet => subnet.netuid === dynInfo.netuid);
+          const nameRaw = ((_dynInfo$subnetIdenti = dynInfo.subnetIdentity) === null || _dynInfo$subnetIdenti === void 0 ? void 0 : _dynInfo$subnetIdenti.subnetName) || String.fromCharCode(...dynInfo.subnetName);
+          const identityName = (_dynInfo$subnetIdenti2 = dynInfo.subnetIdentity) !== null && _dynInfo$subnetIdenti2 !== void 0 && _dynInfo$subnetIdenti2.subnetName ? Buffer.from(dynInfo.subnetIdentity.subnetName.slice(2), 'hex').toString('utf-8') : '';
+          const formattedIdentityName = identityName ? identityName.charAt(0).toUpperCase() + identityName.slice(1).toLowerCase() : '';
+          const name = formattedIdentityName || nameRaw.charAt(0).toUpperCase() + nameRaw.slice(1);
+          const symbol = new TextDecoder('utf-8').decode(Uint8Array.from(dynInfo.tokenSymbol));
+          return {
+            netuid: dynInfo.netuid,
+            name,
+            symbol,
+            ownerHotkey: dynInfo.ownerHotkey,
+            maxAllowedValidators: extraInfo ? extraInfo.maxAllowedValidators : 0,
+            taoIn: dynInfo.taoIn
+          };
+        });
+        this.subnetData = mergedData;
+        this.isInit = true;
+      }
+    } catch (err) {
+      console.error(err);
+      this.isInit = false;
+    }
+  }
+  getDescription() {
+    return 'Stake TAO to earn yield on dTAO';
+  }
+
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    if (!this.isInit) {
+      await this.init();
+    }
+    let cancel = false;
+    const substrateApi = await this.substrateApi.isReady;
+    const updateStakingInfo = async () => {
+      try {
+        if (cancel) {
+          return;
+        }
+        const minDelegatorStake = (await substrateApi.api.query.subtensorModule.nominatorMinRequiredStake()).toPrimitive() || 0;
+        const BNminDelegatorStake = new _bignumber.default(minDelegatorStake.toString());
+        this.subnetData.forEach(subnet => {
+          const netuid = subnet.netuid.toString().padStart(2, '0');
+          const subnetSlug = `${this.slug}__subnet_${netuid.padStart(2, '0')}`;
+          const subnetName = `${subnet.name || 'Unknown'} ${netuid}`;
+          const bnTaoIn = new _util.BN(subnet.taoIn);
+          const data = {
+            ...this.baseInfo,
+            type: this.type,
+            slug: subnetSlug,
+            metadata: {
+              ...this.metadataInfo,
+              name: subnetName,
+              shortName: subnetName,
+              description: this.getDescription(),
+              subnetData: {
+                netuid: subnet.netuid,
+                subnetSymbol: subnet.symbol || 'dTAO'
+              }
+            },
+            statistic: {
+              assetEarning: [{
+                slug: this.nativeToken.slug
+              }],
+              maxCandidatePerFarmer: subnet.maxAllowedValidators,
+              maxWithdrawalRequestPerFarmer: 1,
+              earningThreshold: {
+                join: BNminDelegatorStake.toString(),
+                defaultUnstake: '0',
+                fastUnstake: '0'
+              },
+              eraTime: 24,
+              era: 0,
+              unstakingPeriod: 1.2,
+              tvl: bnTaoIn.toString()
+            }
+          };
+          callback(data);
+        });
+      } catch (error) {
+        console.error('Error updating staking info:', error);
+      }
+    };
+    const subscribeStakingMetadataInterval = () => {
+      updateStakingInfo().catch(console.error);
+    };
+    await substrateApi.isReady;
+    subscribeStakingMetadataInterval();
+    const interval = setInterval(subscribeStakingMetadataInterval, _constants.BITTENSOR_REFRESH_STAKE_APY);
+    return () => {
+      cancel = true;
+      clearInterval(interval);
+    };
+  }
+
+  /* Subscribe pool position */
+
+  async parseNominatorMetadata(chainInfo, address, delegatorState) {
+    const nominationList = [];
+    const getMinDelegatorStake = this.substrateApi.api.query.subtensorModule.nominatorMinRequiredStake();
+    const minDelegatorStake = (await getMinDelegatorStake).toString();
+    let allActiveStake = _util.BN_ZERO;
+    for (const delegate of delegatorState) {
+      const stake = new _bignumber.default(delegate.amount);
+      const originActiveStake = stake.multipliedBy(delegate.rate || new _bignumber.default(1)).toFixed(0).toString();
+      const bnActiveStake = new _util.BN(originActiveStake);
+      if (bnActiveStake.gt(_util.BN_ZERO)) {
+        const delegationStatus = _types.EarningStatus.EARNING_REWARD;
+        allActiveStake = allActiveStake.add(bnActiveStake);
+        nominationList.push({
+          status: delegationStatus,
+          chain: chainInfo.slug,
+          validatorAddress: delegate.owner,
+          activeStake: delegate.amount,
+          validatorMinStake: minDelegatorStake,
+          originActiveStake: originActiveStake,
+          validatorIdentity: delegate.identity
+        });
+      }
+    }
+    const stakingStatus = (0, _utils.getEarningStatusByNominations)(allActiveStake, nominationList);
+    return {
+      status: stakingStatus,
+      balanceToken: this.nativeToken.slug,
+      totalStake: allActiveStake.toString(),
+      activeStake: allActiveStake.toString(),
+      unstakeBalance: '0',
+      isBondedBefore: true,
+      nominations: nominationList,
+      unstakings: []
+    };
+  }
+  async subscribePoolPosition(useAddresses, rsCallback) {
+    if (!this.isInit) {
+      await this.init();
+    }
+    let cancel = false;
+    const substrateApi = await this.substrateApi.isReady;
+    const defaultInfo = this.baseInfo;
+    const chainInfo = this.chainInfo;
+    const _delegateInfo = await this.bittensorCache.get();
+    const getPoolPosition = async () => {
+      const rawDelegateStateInfos = await Promise.all(useAddresses.map(async address => (await substrateApi.api.call.stakeInfoRuntimeApi.getStakeInfoForColdkey(address)).toJSON()));
+      const price = await getTaoToAlphaMapping(this.substrateApi);
+      if (rawDelegateStateInfos && rawDelegateStateInfos.length > 0) {
+        rawDelegateStateInfos.forEach((rawDelegateStateInfo, i) => {
+          const owner = (0, _utils2.reformatAddress)(useAddresses[i], 42);
+          const delegateStateInfo = rawDelegateStateInfo;
+          const subnetPositions = {};
+          for (const delegate of delegateStateInfo) {
+            const hotkey = delegate.hotkey;
+            const netuid = delegate.netuid;
+            const stake = new _bignumber.default(delegate.stake);
+            const taoToAlphaPrice = new _bignumber.default(price[netuid]);
+            if (!subnetPositions[netuid]) {
+              subnetPositions[netuid] = {
+                delegatorState: [],
+                totalBalance: _util.BN_ZERO,
+                originalTotalStake: _util.BN_ZERO
+              };
+            }
+            let identity = '';
+            if (_delegateInfo) {
+              const delegateInfo = _delegateInfo.data.find(info => info.hotkey.ss58 === hotkey);
+              identity = delegateInfo ? delegateInfo.name : '';
+            }
+            subnetPositions[netuid].delegatorState.push({
+              owner: hotkey,
+              amount: stake.toString(),
+              rate: taoToAlphaPrice,
+              identity: identity
+            });
+            subnetPositions[netuid].totalBalance = subnetPositions[netuid].totalBalance.add(new _util.BN(stake.toString()));
+            subnetPositions[netuid].originalTotalStake = subnetPositions[netuid].originalTotalStake.add(new _util.BN(stake.toString()));
+          }
+          Object.values(this.subnetData).forEach(subnet => {
+            const netuid = subnet.netuid;
+            const subnetSlug = `${this.slug}__subnet_${netuid.toString().padStart(2, '0')}`;
+            const subnetName = `${subnet.name || 'Unknown'} ${netuid}`;
+            const subnetSymbol = subnet.symbol || 'dTAO';
+            const {
+              delegatorState = [],
+              originalTotalStake = _util.BN_ZERO
+            } = subnetPositions[netuid] || {};
+            if (delegatorState.length > 0) {
+              this.parseNominatorMetadata(chainInfo, owner, delegatorState).then(nominatorMetadata => {
+                rsCallback({
+                  ...defaultInfo,
+                  ...nominatorMetadata,
+                  address: owner,
+                  type: this.type,
+                  slug: subnetSlug,
+                  subnetData: {
+                    subnetSymbol,
+                    subnetShortName: subnetName,
+                    originalTotalStake: originalTotalStake.toString()
+                  }
+                });
+              }).catch(console.error);
+            } else {
+              rsCallback({
+                ...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: [],
+                slug: subnetSlug,
+                subnetData: {
+                  subnetSymbol,
+                  subnetShortName: subnetName,
+                  originalTotalStake: '0'
+                }
+              });
+            }
+          });
+        });
+      }
+    };
+    const getStakingPositionInterval = async () => {
+      if (cancel) {
+        return;
+      }
+      await getPoolPosition();
+    };
+    getStakingPositionInterval().catch(console.error);
+    const intervalId = setInterval(() => {
+      getStakingPositionInterval().catch(console.error);
+    }, _constants.BITTENSOR_REFRESH_STAKE_INFO);
+    return () => {
+      cancel = true;
+      clearInterval(intervalId);
+    };
+  }
+
+  /* Subscribe pool position */
+
+  /* Get pool targets */
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async getDevnetPoolTargets() {
+    const testnetDelegate = (await this.substrateApi.api.call.delegateInfoRuntimeApi.getDelegates()).toJSON();
+    const getNominatorMinRequiredStake = this.substrateApi.api.query.subtensorModule.nominatorMinRequiredStake();
+    const nominatorMinRequiredStake = (await getNominatorMinRequiredStake).toString();
+    const bnMinBond = new _util.BN(nominatorMinRequiredStake);
+    const filteredDelegates = testnetDelegate.filter(delegate => {
+      return delegate.returnPer1000 !== 0;
+    });
+    return filteredDelegates.map(delegate => ({
+      address: delegate.delegateSs58,
+      totalStake: '0',
+      ownStake: '0',
+      otherStake: '0',
+      minBond: bnMinBond.toString(),
+      nominatorCount: delegate.nominators.length,
+      commission: delegate.take / 1000,
+      blocked: false,
+      isVerified: false,
+      chain: this.chain,
+      isCrowded: false
+    }));
+  }
+  async getMainnetPoolTargets() {
+    const _topValidator = await this.bittensorCache.get();
+    const topValidator = _topValidator;
+    const getNominatorMinRequiredStake = this.substrateApi.api.query.subtensorModule.nominatorMinRequiredStake();
+    const nominatorMinRequiredStake = (await getNominatorMinRequiredStake).toString();
+    const bnMinBond = new _util.BN(nominatorMinRequiredStake);
+    const validatorList = topValidator.data;
+    const validatorAddresses = Object.keys(validatorList);
+    const results = await Promise.all(validatorAddresses.map(i => {
+      const address = validatorList[i].hotkey.ss58;
+      const bnTotalStake = new _util.BN(validatorList[i].stake);
+      const bnOwnStake = new _util.BN(validatorList[i].validator_stake);
+      const otherStake = bnTotalStake.sub(bnOwnStake);
+      const nominatorCount = validatorList[i].nominators;
+      const commission = validatorList[i].take;
+      const roundedCommission = (parseFloat(commission) * 100).toFixed(0);
+      const apr = (parseFloat(validatorList[i].apr) / 10 ** 9 * 100).toFixed(2);
+      const apyCalculate = (0, _utils3.calculateReward)(parseFloat(apr));
+      const name = validatorList[i].name || address;
+      return {
+        address: address,
+        totalStake: bnTotalStake.toString(),
+        ownStake: bnOwnStake.toString(),
+        otherStake: otherStake.toString(),
+        minBond: bnMinBond.toString(),
+        nominatorCount: nominatorCount,
+        commission: roundedCommission,
+        expectedReturn: apyCalculate.apy,
+        blocked: false,
+        isVerified: false,
+        chain: this.chain,
+        isCrowded: false,
+        identity: name
+      };
+    }));
+    return results;
+  }
+  async getPoolTargets() {
+    if (!this.isInit) {
+      await this.init();
+    }
+    if (this.chain === 'bittensor') {
+      return this.getMainnetPoolTargets();
+    } else {
+      return this.getDevnetPoolTargets();
+    }
+  }
+
+  /* Get pool targets */
+
+  /* Join pool action */
+
+  async createJoinExtrinsic(data, positionInfo) {
+    let bondDest = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'Staked';
+    const {
+      amount,
+      netuid,
+      selectedValidators: targetValidators
+    } = data;
+    const chainApi = await this.substrateApi.isReady;
+    const binaryAmount = new _util.BN(amount);
+    const selectedValidatorInfo = targetValidators[0];
+    const hotkey = selectedValidatorInfo.address;
+    const extrinsic = chainApi.api.tx.subtensorModule.addStake(hotkey, netuid, binaryAmount);
+    return [extrinsic, {
+      slug: this.nativeToken.slug,
+      amount: '0'
+    }];
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldUnstake(amount, address, selectedTarget, netuid) {
+    const apiPromise = await this.substrateApi.isReady;
+    const binaryAmount = new _util.BN(amount);
+    if (!selectedTarget) {
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS));
+    }
+    const extrinsic = apiPromise.api.tx.subtensorModule.removeStake(selectedTarget, netuid, binaryAmount);
+    return [_KoniTypes.ExtrinsicType.STAKING_UNBOND, extrinsic];
+  }
+
+  /* Leave pool action */
+}
+exports.default = SubnetTaoStakingPoolHandler;

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

@@ -28,6 +28,12 @@ Object.defineProperty(exports, "RelayNativeStakingPoolHandler", {
     return _relayChain.default;
   }
 });
+Object.defineProperty(exports, "SubnetTaoStakingPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _dtao.default;
+  }
+});
 Object.defineProperty(exports, "TaoNativeStakingPoolHandler", {
   enumerable: true,
   get: function () {
@@ -38,4 +44,5 @@ var _amplitude = _interopRequireDefault(require("./amplitude"));
 var _astar = _interopRequireDefault(require("./astar"));
 var _relayChain = _interopRequireDefault(require("./relay-chain"));
 var _paraChain = _interopRequireDefault(require("./para-chain"));
-var _tao = _interopRequireDefault(require("./tao"));
+var _tao = _interopRequireDefault(require("./tao"));
+var _dtao = _interopRequireDefault(require("./dtao"));