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

package/cjs/services/balance-service/transfer/smart-contract.js

@@ -23,6 +23,7 @@ async function getEVMTransactionObject(_ref) {
   let {
     chain,
     evmApi,
+    fallbackFee,
     feeCustom: _feeCustom,
     feeInfo: _feeInfo,
     feeOption,
@@ -34,13 +35,22 @@ async function getEVMTransactionObject(_ref) {
   const feeCustom = _feeCustom;
   const feeInfo = _feeInfo;
   const feeCombine = (0, _utils3.combineEthFee)(feeInfo, feeOption, feeCustom);
+  let errorOnEstimateFee = '';
   const transactionObject = {
     to: to,
     value: value,
     from: from,
     ...feeCombine
   };
-  const gasLimit = await evmApi.api.eth.estimateGas(transactionObject);
+  const gasLimit = await evmApi.api.eth.estimateGas(transactionObject).catch(e => {
+    console.log('Cannot estimate fee with native transfer on', chain, e);
+    if (fallbackFee) {
+      errorOnEstimateFee = e.message;
+      return 21000;
+    } else {
+      throw Error('Unable to estimate fee for this transaction. Edit fee and try again.');
+    }
+  });
   transactionObject.gas = gasLimit;
   let estimateFee;
   if (feeCombine.maxFeePerGas) {
@@ -54,12 +64,14 @@ async function getEVMTransactionObject(_ref) {
     const numberReplace = 18 - 12;
     transactionObject.value = transactionObject.value.substring(0, transactionObject.value.length - 6) + new Array(numberReplace).fill('0').join('');
   }
-  return [transactionObject, transactionObject.value.toString()];
+  return [transactionObject, transactionObject.value.toString(), errorOnEstimateFee];
 }
 async function getERC20TransactionObject(_ref2) {
   let {
     assetAddress,
+    chain,
     evmApi,
+    fallbackFee,
     feeCustom: _feeCustom,
     feeInfo: _feeInfo,
     feeOption,
@@ -72,6 +84,7 @@ async function getERC20TransactionObject(_ref2) {
   const feeCustom = _feeCustom;
   let freeAmount = new _bignumber.default(0);
   let transferValue = value;
+  let errorOnEstimateFee = '';
   if (transferAll) {
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
     const bal = await erc20Contract.methods.balanceOf(from).call();
@@ -86,6 +99,14 @@ async function getERC20TransactionObject(_ref2) {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access
   const gasLimit = await erc20Contract.methods.transfer(to, transferValue).estimateGas({
     from
+  }).catch(e => {
+    console.log('Cannot estimate fee with token contract', assetAddress, chain, e);
+    if (fallbackFee) {
+      errorOnEstimateFee = e.message;
+      return 70000;
+    } else {
+      throw Error('Unable to estimate fee for this transaction. Edit fee and try again.');
+    }
   });
   const feeInfo = _feeInfo;
   const feeCombine = (0, _utils3.combineEthFee)(feeInfo, feeOption, feeCustom);
@@ -101,7 +122,7 @@ async function getERC20TransactionObject(_ref2) {
     transferValue = freeAmount.toFixed(0);
     transactionObject.data = generateTransferData(to, transferValue);
   }
-  return [transactionObject, transferValue];
+  return [transactionObject, transferValue, errorOnEstimateFee];
 }
 async function getERC721Transaction(web3Api, chain, contractAddress, senderAddress, recipientAddress, tokenId, _feeInfo) {
   // eslint-disable-next-line @typescript-eslint/no-unsafe-argument

package/cjs/services/buy-service/constants/token.js

@@ -26,6 +26,9 @@ const DEFAULT_SERVICE_INFO = {
   },
   moonpay: {
     ...DEFAULT_BUY_SERVICE
+  },
+  meld: {
+    ...DEFAULT_BUY_SERVICE
   }
 };
 exports.DEFAULT_SERVICE_INFO = DEFAULT_SERVICE_INFO;

package/cjs/services/chain-service/index.js

@@ -219,6 +219,17 @@ class ChainService {
     });
     return assetHubToken;
   }
+  getHydrationAssetIdMap(chain) {
+    const hydrationAssetIdMap = {};
+    Object.values(this.getAssetRegistry()).forEach(asset => {
+      const originChain = (0, _utils._getAssetOriginChain)(asset);
+      const assetId = (0, _utils._getTokenOnChainAssetId)(asset);
+      if (originChain === chain && assetId !== '-1') {
+        hydrationAssetIdMap[asset.slug] = assetId;
+      }
+    });
+    return hydrationAssetIdMap;
+  }
   getChainInfoMap() {
     return this.dataMap.chainInfoMap;
   }

package/cjs/services/earning-service/constants/chains.js

@@ -23,7 +23,7 @@ const _STAKING_CHAIN_GROUP = {
   lending: ['interlay'],
   krest_network: ['krest_network'],
   manta: ['manta_network'],
-  bittensor: ['bittensor', 'bittensor_devnet'],
+  bittensor: ['bittensor', 'bittensor_testnet'],
   mythos: ['mythos', 'muse_testnet']
 };
 exports._STAKING_CHAIN_GROUP = _STAKING_CHAIN_GROUP;

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

@@ -113,11 +113,13 @@ class BasePoolHandler {
     return false;
   }
   async getPoolInfo() {
-    return await this.state.earningService.getYieldPool(this.slug);
+    let slug = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.slug;
+    return await this.state.earningService.getYieldPool(slug);
   }
   async getPoolPosition(address) {
+    let slug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.slug;
     const originAddress = (0, _utils2.reformatAddress)(address);
-    return await this.state.earningService.getYieldPosition(originAddress, this.slug);
+    return await this.state.earningService.getYieldPosition(originAddress, slug);
   }
 
   /* Subscribe data */
@@ -132,7 +134,7 @@ 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,
@@ -254,11 +256,11 @@ 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);
     }
   }
 
@@ -268,6 +270,10 @@ class BasePoolHandler {
 
   /** Create `transaction` to withdraw unstaked amount */
 
+  /** Check handler can handle slug */
+  canHandleSlug(slug) {
+    return this.slug === slug;
+  }
   /* Other actions */
 }
 exports.default = BasePoolHandler;

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

@@ -32,10 +32,11 @@ class BaseParaNativeStakingPoolHandler extends _base.default {
     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 _util.BN(amount);
     if (bnAmount.lte(_util.BN_ZERO)) {
@@ -101,10 +102,10 @@ class BaseParaNativeStakingPoolHandler extends _base.default {
   /**
    * @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.TransactionError(_types.BasicTxErrorType.INTERNAL_ERROR)];
     }

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

@@ -100,6 +100,7 @@ class BaseNativeStakingPoolHandler extends _base.default {
     const {
       address,
       amount,
+      netuid,
       slug,
       targets
     } = params;
@@ -108,7 +109,8 @@ class BaseNativeStakingPoolHandler extends _base.default {
       amount,
       address,
       slug,
-      selectedValidators
+      selectedValidators,
+      netuid
     };
     const positionInfo = await this.getPoolPosition(address);
     const [, fee] = await this.createJoinExtrinsic(data, positionInfo);
@@ -119,9 +121,10 @@ class BaseNativeStakingPoolHandler extends _base.default {
     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/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;