@subwallet/extension-base 1.3.23-0 → 1.3.25-0

package/services/earning-service/handlers/base.d.ts

@@ -49,8 +49,8 @@ export default abstract class BasePoolHandler {
     createClaimNotification(claimItemInfo: EarningRewardItem, tokenInfo: _ChainAsset): Promise<void>;
     /** Can mint when haven't enough native token (use input token for fee) */
     get isPoolSupportAlternativeFee(): boolean;
-    getPoolInfo(): Promise<YieldPoolInfo | undefined>;
-    getPoolPosition(address: string): Promise<YieldPositionInfo | undefined>;
+    getPoolInfo(slug?: string): Promise<YieldPoolInfo | undefined>;
+    getPoolPosition(address: string, slug?: string): Promise<YieldPositionInfo | undefined>;
     /** Subscribe pool info */
     abstract subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
     /** Subscribe pool position */
@@ -99,17 +99,19 @@ export default abstract class BasePoolHandler {
     /** Create `transaction` to join the pool step-by-step */
     abstract handleYieldJoin(data: SubmitYieldJoinData, path: OptimalYieldPath, currentStep: number): Promise<HandleYieldStepData>;
     /** Validate param to leave the pool */
-    abstract validateYieldLeave(amount: string, address: string, fastLeave: boolean, selectedTarget?: string): Promise<TransactionError[]>;
+    abstract validateYieldLeave(amount: string, address: string, fastLeave: boolean, selectedTarget?: string, slug?: string): Promise<TransactionError[]>;
     /** Create `transaction` to leave the pool normal (default unstake) */
-    protected abstract handleYieldUnstake(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+    protected abstract handleYieldUnstake(amount: string, address: string, selectedTarget?: string, netuid?: number): Promise<[ExtrinsicType, TransactionData]>;
     /** Create `transaction` to leave the pool fast (swap token) */
     protected abstract handleYieldRedeem(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
     /** Create `transaction` to leave the pool */
-    handleYieldLeave(fastLeave: boolean, amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;
+    handleYieldLeave(fastLeave: boolean, amount: string, address: string, selectedTarget?: string, netuid?: number): Promise<[ExtrinsicType, TransactionData]>;
     /** Create `transaction` to withdraw unstaked amount */
     abstract handleYieldWithdraw(address: string, unstakingInfo: UnstakingInfo): Promise<TransactionData>;
     /** Create `transaction` to cancel unstake */
     abstract handleYieldCancelUnstake(params: StakeCancelWithdrawalParams): Promise<TransactionData>;
     /** Create `transaction` to claim reward */
     abstract handleYieldClaimReward(address: string, bondReward?: boolean): Promise<TransactionData>;
+    /** Check handler can handle slug */
+    canHandleSlug(slug: string): boolean;
 }

package/services/earning-service/handlers/base.js

@@ -107,12 +107,12 @@ export default class BasePoolHandler {
   get isPoolSupportAlternativeFee() {
     return false;
   }
-  async getPoolInfo() {
-    return await this.state.earningService.getYieldPool(this.slug);
+  async getPoolInfo(slug = this.slug) {
+    return await this.state.earningService.getYieldPool(slug);
   }
-  async getPoolPosition(address) {
+  async getPoolPosition(address, slug = this.slug) {
     const originAddress = reformatAddress(address);
-    return await this.state.earningService.getYieldPosition(originAddress, this.slug);
+    return await this.state.earningService.getYieldPosition(originAddress, slug);
   }
 
   /* Subscribe data */
@@ -127,7 +127,7 @@ export default class BasePoolHandler {
 
   async earlyValidate(request) {
     var _poolInfo$statistic, _poolInfo$statistic2, _poolInfo$statistic2$;
-    const poolInfo = await this.getPoolInfo();
+    const poolInfo = await this.getPoolInfo(request.slug);
     if (!poolInfo || !((_poolInfo$statistic = poolInfo.statistic) !== null && _poolInfo$statistic !== void 0 && _poolInfo$statistic.earningThreshold.join)) {
       return {
         passed: false,
@@ -249,11 +249,11 @@ export default class BasePoolHandler {
   /** Validate param to join the pool */
 
   /** Create `transaction` to leave the pool */
-  async handleYieldLeave(fastLeave, amount, address, selectedTarget) {
+  async handleYieldLeave(fastLeave, amount, address, selectedTarget, netuid) {
     if (fastLeave) {
       return this.handleYieldRedeem(amount, address, selectedTarget);
     } else {
-      return this.handleYieldUnstake(amount, address, selectedTarget);
+      return this.handleYieldUnstake(amount, address, selectedTarget, netuid);
     }
   }
 
@@ -263,5 +263,9 @@ export default class BasePoolHandler {
 
   /** Create `transaction` to withdraw unstaked amount */
 
+  /** Check handler can handle slug */
+  canHandleSlug(slug) {
+    return this.slug === slug;
+  }
   /* Other actions */
 }

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

@@ -7,5 +7,5 @@ export default abstract class BaseParaNativeStakingPoolHandler extends BaseNativ
     /**
      * @todo Recheck
      * */
-    validateYieldLeave(amount: string, address: string, fastLeave: boolean, selectedTarget?: string): Promise<TransactionError[]>;
+    validateYieldLeave(amount: string, address: string, fastLeave: boolean, selectedTarget?: string, slug?: string): Promise<TransactionError[]>;
 }

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

@@ -25,10 +25,11 @@ export default class BaseParaNativeStakingPoolHandler extends BaseNativeStakingP
     const {
       address,
       amount,
-      selectedValidators
+      selectedValidators,
+      slug
     } = data;
-    const poolInfo = await this.getPoolInfo();
-    const poolPosition = await this.getPoolPosition(address);
+    const poolInfo = await this.getPoolInfo(slug);
+    const poolPosition = await this.getPoolPosition(address, slug);
     const chainInfo = this.chainInfo;
     const bnAmount = new BN(amount);
     if (bnAmount.lte(BN_ZERO)) {
@@ -94,10 +95,10 @@ export default class BaseParaNativeStakingPoolHandler extends BaseNativeStakingP
   /**
    * @todo Recheck
    * */
-  async validateYieldLeave(amount, address, fastLeave, selectedTarget) {
+  async validateYieldLeave(amount, address, fastLeave, selectedTarget, slug) {
     const errors = [];
-    const poolInfo = await this.getPoolInfo();
-    const poolPosition = await this.getPoolPosition(address);
+    const poolInfo = await this.getPoolInfo(slug);
+    const poolPosition = await this.getPoolPosition(address, slug);
     if (!poolInfo || !poolInfo.statistic || !poolPosition || fastLeave || !selectedTarget) {
       return [new TransactionError(BasicTxErrorType.INTERNAL_ERROR)];
     }

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

@@ -13,7 +13,7 @@ export default abstract class BaseNativeStakingPoolHandler extends BasePoolHandl
     getPoolReward(useAddresses: string[], callBack: (rs: EarningRewardItem) => void): Promise<VoidFunction>;
     getPoolRewardHistory(useAddresses: string[], callBack: (rs: EarningRewardHistoryItem) => void): Promise<VoidFunction>;
     get defaultSubmitStep(): YieldStepBaseInfo;
-    abstract createJoinExtrinsic(data: SubmitJoinNativeStaking, positionInfo?: YieldPositionInfo, bondDest?: string): Promise<[TransactionData, YieldTokenBaseInfo]>;
+    abstract createJoinExtrinsic(data: SubmitJoinNativeStaking, positionInfo?: YieldPositionInfo, bondDest?: string, netuid?: number): Promise<[TransactionData, YieldTokenBaseInfo]>;
     protected getSubmitStep(params: OptimalYieldPathParams): Promise<YieldStepBaseInfo>;
     handleYieldJoin(_data: SubmitYieldJoinData, path: OptimalYieldPath, currentStep: number): Promise<HandleYieldStepData>;
     handleYieldRedeem(amount: string, address: string, selectedTarget?: string): Promise<[ExtrinsicType, TransactionData]>;

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

@@ -92,6 +92,7 @@ export default class BaseNativeStakingPoolHandler extends BasePoolHandler {
     const {
       address,
       amount,
+      netuid,
       slug,
       targets
     } = params;
@@ -100,7 +101,8 @@ export default class BaseNativeStakingPoolHandler extends BasePoolHandler {
       amount,
       address,
       slug,
-      selectedValidators
+      selectedValidators,
+      netuid
     };
     const positionInfo = await this.getPoolPosition(address);
     const [, fee] = await this.createJoinExtrinsic(data, positionInfo);
@@ -111,9 +113,10 @@ export default class BaseNativeStakingPoolHandler extends BasePoolHandler {
     const {
       address,
       amount,
-      selectedValidators
+      selectedValidators,
+      slug
     } = data;
-    const positionInfo = await this.getPoolPosition(address);
+    const positionInfo = await this.getPoolPosition(address, slug);
     const [extrinsic] = await this.createJoinExtrinsic(data, positionInfo);
     const bondingData = {
       poolPosition: positionInfo,

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

@@ -0,0 +1,64 @@
+import { _ChainInfo } from '@subwallet/chain-list/types';
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
+import BaseParaStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/native-staking/base-para';
+import { BaseYieldPositionInfo, StakeCancelWithdrawalParams, SubmitJoinNativeStaking, TransactionData, UnstakingInfo, ValidatorInfo, YieldPoolInfo, YieldPoolMethodInfo, YieldPoolType, YieldPositionInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import { BigNumber } from 'bignumber.js';
+export interface SubnetData {
+    netuid: number;
+    name: string;
+    symbol: string;
+    ownerHotkey: string;
+    maxAllowedValidators: number;
+    taoIn: number;
+}
+interface TaoStakingStakeOption {
+    owner: string;
+    amount: string;
+    rate?: BigNumber;
+    identity?: string;
+}
+export interface RawDelegateState {
+    data: Array<{
+        hotkey_name: string;
+        hotkey: {
+            ss58: string;
+        };
+        stake: string;
+    }>;
+}
+declare type Nominators = [Array<[number, number]>];
+export interface TestnetBittensorDelegateInfo {
+    delegateSs58: string;
+    take: number;
+    nominators: Nominators;
+    returnPer1000: number;
+}
+export declare const getTaoToAlphaMapping: (substrateApi: _SubstrateApi) => Promise<Record<number, string>>;
+export default class SubnetTaoStakingPoolHandler extends BaseParaStakingPoolHandler {
+    handleYieldWithdraw(address: string, unstakingInfo: UnstakingInfo): Promise<TransactionData>;
+    handleYieldCancelUnstake(params: StakeCancelWithdrawalParams): Promise<TransactionData>;
+    readonly type = YieldPoolType.SUBNET_STAKING;
+    slug: string;
+    protected name: string;
+    protected shortName: string;
+    subnetData: SubnetData[];
+    private isInit;
+    private bittensorCache;
+    readonly availableMethod: YieldPoolMethodInfo;
+    constructor(state: KoniState, chain: string);
+    canHandleSlug(slug: string): boolean;
+    get maintainBalance(): string;
+    private init;
+    protected getDescription(): string;
+    subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
+    parseNominatorMetadata(chainInfo: _ChainInfo, address: string, delegatorState: TaoStakingStakeOption[]): Promise<Omit<YieldPositionInfo, keyof BaseYieldPositionInfo>>;
+    subscribePoolPosition(useAddresses: string[], rsCallback: (rs: YieldPositionInfo) => void): Promise<VoidFunction>;
+    private getDevnetPoolTargets;
+    private getMainnetPoolTargets;
+    getPoolTargets(): Promise<ValidatorInfo[]>;
+    createJoinExtrinsic(data: SubmitJoinNativeStaking, positionInfo?: YieldPositionInfo, bondDest?: string): Promise<[TransactionData, YieldTokenBaseInfo]>;
+    handleYieldUnstake(amount: string, address: string, selectedTarget?: string, netuid?: number): Promise<[ExtrinsicType, TransactionData]>;
+}
+export {};

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

@@ -0,0 +1,434 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
+import { BITTENSOR_REFRESH_STAKE_APY, BITTENSOR_REFRESH_STAKE_INFO } from '@subwallet/extension-base/constants';
+import { getEarningStatusByNominations } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
+import BaseParaStakingPoolHandler from '@subwallet/extension-base/services/earning-service/handlers/native-staking/base-para';
+import { BasicTxErrorType, EarningStatus, YieldPoolType } from '@subwallet/extension-base/types';
+import { reformatAddress } from '@subwallet/extension-base/utils';
+import BigN from 'bignumber.js';
+import { BN, BN_TEN, BN_ZERO } from '@polkadot/util';
+import { calculateReward } from "../../utils/index.js";
+import { BittensorCache } from "./tao.js";
+export 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 BigN(subnet.taoIn) : new BigN(0);
+    const alphaIn = subnet !== null && subnet !== void 0 && subnet.alphaIn ? new BigN(subnet.alphaIn) : new BigN(0);
+    if (netuid === 0) {
+      acc[netuid] = '1';
+    } else if (alphaIn.gt(0)) {
+      acc[netuid] = taoIn.dividedBy(alphaIn).toString();
+    } else {
+      acc[netuid] = '1';
+    }
+    return acc;
+  }, {});
+};
+export default class SubnetTaoStakingPoolHandler extends BaseParaStakingPoolHandler {
+  /* Unimplemented function  */
+  handleYieldWithdraw(address, unstakingInfo) {
+    throw new Error('Method not implemented.');
+  }
+  handleYieldCancelUnstake(params) {
+    throw new Error('Method not implemented.');
+  }
+  /* Unimplemented function  */
+
+  // @ts-ignore
+  type = 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 = BittensorCache.getInstance();
+  }
+  canHandleSlug(slug) {
+    return slug.startsWith(`${this.slug}__`);
+  }
+  get maintainBalance() {
+    const ed = new BN(this.nativeToken.minAmount || '0');
+    const calculateMaintainBalance = new BN(15).mul(ed).div(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 BigN(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 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, 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 = BN_ZERO;
+    for (const delegate of delegatorState) {
+      const stake = new BigN(delegate.amount);
+      const originActiveStake = stake.multipliedBy(delegate.rate || new BigN(1)).toFixed(0).toString();
+      const bnActiveStake = new BN(originActiveStake);
+      if (bnActiveStake.gt(BN_ZERO)) {
+        const delegationStatus = 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 = 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 = 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 BigN(delegate.stake);
+            const taoToAlphaPrice = new BigN(price[netuid]);
+            if (!subnetPositions[netuid]) {
+              subnetPositions[netuid] = {
+                delegatorState: [],
+                totalBalance: BN_ZERO,
+                originalTotalStake: 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 BN(stake.toString()));
+            subnetPositions[netuid].originalTotalStake = subnetPositions[netuid].originalTotalStake.add(new 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 = 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: 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);
+    }, 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 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 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 BN(validatorList[i].stake);
+      const bnOwnStake = new 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 = 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, bondDest = 'Staked') {
+    const {
+      amount,
+      netuid,
+      selectedValidators: targetValidators
+    } = data;
+    const chainApi = await this.substrateApi.isReady;
+    const binaryAmount = new 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 BN(amount);
+    if (!selectedTarget) {
+      return Promise.reject(new TransactionError(BasicTxErrorType.INVALID_PARAMS));
+    }
+    const extrinsic = apiPromise.api.tx.subtensorModule.removeStake(selectedTarget, netuid, binaryAmount);
+    return [ExtrinsicType.STAKING_UNBOND, extrinsic];
+  }
+
+  /* Leave pool action */
+}

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

@@ -3,3 +3,4 @@ export { default as AstarNativeStakingPoolHandler } from './astar';
 export { default as RelayNativeStakingPoolHandler } from './relay-chain';
 export { default as ParaNativeStakingPoolHandler } from './para-chain';
 export { default as TaoNativeStakingPoolHandler } from './tao';
+export { default as SubnetTaoStakingPoolHandler } from './dtao';

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

@@ -5,4 +5,5 @@ export { default as AmplitudeNativeStakingPoolHandler } from "./amplitude.js";
 export { default as AstarNativeStakingPoolHandler } from "./astar.js";
 export { default as RelayNativeStakingPoolHandler } from "./relay-chain.js";
 export { default as ParaNativeStakingPoolHandler } from "./para-chain.js";
-export { default as TaoNativeStakingPoolHandler } from "./tao.js";
+export { default as TaoNativeStakingPoolHandler } from "./tao.js";
+export { default as SubnetTaoStakingPoolHandler } from "./dtao.js";