@subwallet/extension-base 1.2.33-0 → 1.3.2-0

package/cjs/services/balance-service/helpers/subscribe/substrate/index.js

@@ -19,7 +19,9 @@ var _wasm = require("@subwallet/extension-base/koni/api/contract-handler/wasm");
 var _utils = require("@subwallet/extension-base/koni/api/contract-handler/wasm/utils");
 var _constants2 = require("@subwallet/extension-base/services/chain-service/constants");
 var _utils2 = require("@subwallet/extension-base/services/chain-service/utils");
-var _utils3 = require("@subwallet/extension-base/utils");
+var _tao = require("@subwallet/extension-base/services/earning-service/handlers/native-staking/tao");
+var _utils3 = require("@subwallet/extension-base/services/earning-service/utils");
+var _utils4 = require("@subwallet/extension-base/utils");
 var _bignumber = _interopRequireDefault(require("bignumber.js"));
 var _evm = require("../evm");
 var _equilibrium = require("./equilibrium");
@@ -138,6 +140,13 @@ const subscribeWithSystemAccountPallet = async _ref => {
       args: addresses
     });
   }
+  let bittensorStakingBalances = new Array(addresses.length).fill(BigInt(0));
+  if (['bittensor'].includes(chainInfo.slug)) {
+    bittensorStakingBalances = await Promise.all(addresses.map(async address => {
+      const rawDelegateState = await (0, _tao.fetchTaoDelegateState)(address);
+      return (0, _utils3.getTaoTotalStake)(rawDelegateState);
+    }));
+  }
   const subscription = substrateApi.subscribeDataWithMulti(params, rs => {
     const balances = rs[systemAccountKey];
     const poolMemberInfos = rs[poolMembersKey];
@@ -151,6 +160,7 @@ const subscribeWithSystemAccountPallet = async _ref => {
         const nominationPoolBalance = poolMemberInfo ? (0, _nominationpoolsPallet._getTotalStakeInNominationPool)(poolMemberInfo) : BigInt(0);
         totalLockedFromTransfer += nominationPoolBalance;
       }
+      totalLockedFromTransfer += bittensorStakingBalances[index];
       return {
         address: addresses[index],
         tokenSlug: (0, _utils2._getChainNativeTokenSlug)(chainInfo),
@@ -189,7 +199,7 @@ const subscribeForeignAssetBalance = async _ref2 => {
     substrateApi
   } = _ref2;
   const foreignAssetsAccountKey = 'query_foreignAssets_account';
-  const tokenMap = (0, _utils3.filterAssetsByChainAndType)(assetMap, chainInfo.slug, [_types._AssetType.LOCAL]);
+  const tokenMap = (0, _utils4.filterAssetsByChainAndType)(assetMap, chainInfo.slug, [_types._AssetType.LOCAL]);
   const unsubList = await Promise.all(Object.values(tokenMap).map(tokenInfo => {
     try {
       if ((0, _utils2._isBridgedToken)(tokenInfo)) {
@@ -256,7 +266,7 @@ const subscribePSP22Balance = _ref3 => {
   } = _ref3;
   const chain = chainInfo.slug;
   const psp22ContractMap = {};
-  const tokenList = (0, _utils3.filterAssetsByChainAndType)(assetMap, chain, [_types._AssetType.PSP22]);
+  const tokenList = (0, _utils4.filterAssetsByChainAndType)(assetMap, chain, [_types._AssetType.PSP22]);
   Object.entries(tokenList).forEach(_ref4 => {
     let [slug, tokenInfo] = _ref4;
     psp22ContractMap[slug] = (0, _wasm.getPSP22ContractPromise)(substrateApi.api, (0, _utils2._getContractAddressOfToken)(tokenInfo));
@@ -317,7 +327,7 @@ const subscribeTokensAccountsPallet = async _ref5 => {
   } = _ref5;
   const tokensAccountsKey = 'query_tokens_accounts';
   const tokenTypes = includeNativeToken ? [_types._AssetType.NATIVE, _types._AssetType.LOCAL] : [_types._AssetType.LOCAL];
-  const tokenMap = (0, _utils3.filterAssetsByChainAndType)(assetMap, chainInfo.slug, tokenTypes);
+  const tokenMap = (0, _utils4.filterAssetsByChainAndType)(assetMap, chainInfo.slug, tokenTypes);
   const unsubList = await Promise.all(Object.values(tokenMap).map(tokenInfo => {
     try {
       const params = [{
@@ -363,7 +373,7 @@ const subscribeAssetsAccountPallet = async _ref6 => {
     substrateApi
   } = _ref6;
   const assetsAccountKey = 'query_assets_account';
-  const tokenMap = (0, _utils3.filterAssetsByChainAndType)(assetMap, chainInfo.slug, [_types._AssetType.LOCAL]);
+  const tokenMap = (0, _utils4.filterAssetsByChainAndType)(assetMap, chainInfo.slug, [_types._AssetType.LOCAL]);
   Object.values(tokenMap).forEach(token => {
     if (_constants2._MANTA_ZK_CHAIN_GROUP.includes(token.originChain) && token.symbol.startsWith(_constants2._ZK_ASSET_PREFIX)) {
       delete tokenMap[token.slug];
@@ -432,7 +442,7 @@ const subscribeOrmlTokensPallet = async _ref7 => {
     substrateApi
   } = _ref7;
   const ormlTokensAccountsKey = 'query_ormlTokens_accounts';
-  const tokenMap = (0, _utils3.filterAssetsByChainAndType)(assetMap, chainInfo.slug, [_types._AssetType.LOCAL]);
+  const tokenMap = (0, _utils4.filterAssetsByChainAndType)(assetMap, chainInfo.slug, [_types._AssetType.LOCAL]);
   const unsubList = Object.values(tokenMap).map(tokenInfo => {
     try {
       const params = [{

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

@@ -64,7 +64,8 @@ const _NFT_CHAIN_GROUP = {
   unique_evm: ['unique_evm'],
   bitcountry: ['bitcountry', 'pioneer', 'continuum_network'],
   vara: ['vara_network'],
-  avail: ['avail_mainnet']
+  avail: ['avail_mainnet'],
+  ternoa: ['ternoa', 'ternoa_alphanet']
 };
 
 // Staking--------------------------------------------------------------------------------------------------------------

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

@@ -1603,21 +1603,18 @@ class ChainService {
     const assetSettings = await this.getAssetSettings();
     const activeChainSlugs = this.getActiveChainSlugs();
     const assetRegistry = this.getAssetRegistry();
-    if (Object.keys(assetSettings).length === 0) {
-      // only initiate the first time
-      Object.values(assetRegistry).forEach(assetInfo => {
-        const isSettingExisted = (assetInfo.slug in assetSettings);
+    Object.values(assetRegistry).forEach(assetInfo => {
+      const isSettingExisted = (assetInfo.slug in assetSettings);
 
-        // Set visible for every enabled chains
-        if (activeChainSlugs.includes(assetInfo.originChain) && !isSettingExisted) {
-          // Setting only exist when set either by chain settings or user
-          assetSettings[assetInfo.slug] = {
-            visible: true
-          };
-        }
-      });
-      this.setAssetSettings(assetSettings, false);
-    }
+      // Set visible for every enabled chains
+      if (activeChainSlugs.includes(assetInfo.originChain) && !isSettingExisted) {
+        // Setting only exist when set either by chain settings or user
+        assetSettings[assetInfo.slug] = {
+          visible: true
+        };
+      }
+    });
+    this.setAssetSettings(assetSettings, false);
     this.eventService.emit('asset.ready', true);
   }
   setAssetSettings(assetSettings) {

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

@@ -22,7 +22,8 @@ const _STAKING_CHAIN_GROUP = {
   liquidStaking: ['bifrost_dot', 'acala', 'parallel', 'moonbeam'],
   lending: ['interlay'],
   krest_network: ['krest_network'],
-  manta: ['manta_network']
+  manta: ['manta_network'],
+  bittensor: ['bittensor', 'bittensor_devnet']
 };
 exports._STAKING_CHAIN_GROUP = _STAKING_CHAIN_GROUP;
 const TON_CHAINS = ['ton', 'ton_testnet'];

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

@@ -28,7 +28,14 @@ Object.defineProperty(exports, "RelayNativeStakingPoolHandler", {
     return _relayChain.default;
   }
 });
+Object.defineProperty(exports, "TaoNativeStakingPoolHandler", {
+  enumerable: true,
+  get: function () {
+    return _tao.default;
+  }
+});
 var _amplitude = _interopRequireDefault(require("./amplitude"));
 var _astar = _interopRequireDefault(require("./astar"));
 var _relayChain = _interopRequireDefault(require("./relay-chain"));
-var _paraChain = _interopRequireDefault(require("./para-chain"));
+var _paraChain = _interopRequireDefault(require("./para-chain"));
+var _tao = _interopRequireDefault(require("./tao"));

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

@@ -0,0 +1,415 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.bittensorApiKey = exports.BITTENSOR_API_KEY_2 = exports.BITTENSOR_API_KEY_1 = void 0;
+exports.fetchDelegates = fetchDelegates;
+exports.fetchTaoDelegateState = fetchTaoDelegateState;
+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");
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+// interface ValidatorName {
+//   count: number;
+//   delegates: {
+//     name: string;
+//   }[];
+// }
+const BITTENSOR_API_KEY_1 = process.env.BITTENSOR_API_KEY_1 || '';
+exports.BITTENSOR_API_KEY_1 = BITTENSOR_API_KEY_1;
+const BITTENSOR_API_KEY_2 = process.env.BITTENSOR_API_KEY_2 || '';
+exports.BITTENSOR_API_KEY_2 = BITTENSOR_API_KEY_2;
+function random() {
+  for (var _len = arguments.length, keys = new Array(_len), _key = 0; _key < _len; _key++) {
+    keys[_key] = arguments[_key];
+  }
+  const validKeys = keys.filter(key => key);
+  const randomIndex = Math.floor(Math.random() * validKeys.length);
+  return validKeys[randomIndex];
+}
+const bittensorApiKey = () => {
+  return random(BITTENSOR_API_KEY_1, BITTENSOR_API_KEY_2);
+};
+
+/* Fetch data */
+exports.bittensorApiKey = bittensorApiKey;
+async function fetchDelegates() {
+  const apiKey = bittensorApiKey();
+  return new Promise(function (resolve) {
+    fetch('https://api.taostats.io/api/v1/validator?order=amount%3Adesc&limit=100', {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `${apiKey}`
+      }
+    }).then(resp => {
+      resolve(resp.json());
+    }).catch(console.error);
+  });
+}
+async function fetchTaoDelegateState(address) {
+  const apiKey = bittensorApiKey();
+  return new Promise(function (resolve) {
+    fetch(`https://api.taostats.io/api/v1/delegate/balance?nominator_address=${address}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `${apiKey}`
+      }
+    }).then(resp => {
+      resolve(resp.json());
+    }).catch(console.error);
+  });
+}
+
+/* Fetch data */
+
+const testnetDelegate = {
+  '5G6wdAdS7hpBuH1tjuZDhpzrGw9Wf71WEVakDCxHDm1cxEQ2': {
+    name: '0x436c6f776e4e616d65f09fa4a1',
+    url: 'https://example.com  ',
+    image: 'https://example.com/image.png',
+    discord: '0xe28094446973636f7264',
+    description: 'This is an example identity.',
+    additional: ''
+  }
+};
+class TaoNativeStakingPoolHandler extends _basePara.default {
+  /* Unimplemented function  */
+  handleYieldWithdraw(address, unstakingInfo) {
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+  }
+  handleYieldCancelUnstake(params) {
+    return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.UNSUPPORTED));
+  }
+  /* Unimplemented function  */
+
+  // async fetchDelegatesInfo (address: string): Promise<ValidatorName> {
+  //   const apiKey = this.bittensorApiKey;
+
+  //   return new Promise(function (resolve) {
+  //     fetch(`https://api.taostats.io/api/v1/delegate/info?address=${address}`, {
+  //       method: 'GET',
+  //       headers: {
+  //         'Content-Type': 'application/json',
+  //         Authorization: `${apiKey}`
+  //       }
+  //     }).then((resp) => {
+  //       resolve(resp.json());
+  //     }).catch(console.error);
+  //   });
+  // }
+
+  /* Subscribe pool info */
+
+  async subscribePoolInfo(callback) {
+    let cancel = false;
+    const substrateApi = this.substrateApi;
+    const updateStakingInfo = async () => {
+      try {
+        if (cancel) {
+          return;
+        }
+        const minDelegatorStake = await substrateApi.api.query.subtensorModule.nominatorMinRequiredStake();
+        const BNminDelegatorStake = new _bignumber.default(minDelegatorStake.toString());
+        const data = {
+          ...this.baseInfo,
+          type: this.type,
+          metadata: {
+            ...this.metadataInfo,
+            description: this.getDescription('0')
+          },
+          statistic: {
+            assetEarning: [{
+              slug: this.nativeToken.slug
+            }],
+            maxCandidatePerFarmer: 16,
+            maxWithdrawalRequestPerFarmer: 1,
+            earningThreshold: {
+              join: BNminDelegatorStake.toString(),
+              defaultUnstake: '0',
+              fastUnstake: '0'
+            },
+            eraTime: 1.2,
+            era: 0,
+            unstakingPeriod: 1.2
+          }
+        };
+        callback(data);
+      } catch (error) {
+        console.log(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 activeStake = delegate.amount;
+      const bnActiveStake = new _util.BN(activeStake);
+      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: activeStake,
+          validatorMinStake: minDelegatorStake
+        });
+      }
+    }
+    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) {
+    let cancel = false;
+    const substrateApi = await this.substrateApi.isReady;
+    const defaultInfo = this.baseInfo;
+    const chainInfo = this.chainInfo;
+    const getDevnetPoolPosition = async () => {
+      const testnetAddress = Object.keys(testnetDelegate)[0];
+      const delegatorState = [];
+      let bnTotalBalance = _util.BN_ZERO;
+      const stakePromises = useAddresses.map(async address => {
+        const stakeAmount = (await substrateApi.api.query.subtensorModule.stake(testnetAddress, address)).toString();
+        const bnStakeAmount = new _util.BN(stakeAmount);
+        bnTotalBalance = bnTotalBalance.add(bnStakeAmount);
+        delegatorState.push({
+          owner: testnetAddress,
+          amount: bnStakeAmount.toString()
+        });
+        rsCallback({
+          ...defaultInfo,
+          type: this.type,
+          address: address,
+          balanceToken: this.nativeToken.slug,
+          totalStake: bnTotalBalance.toString(),
+          activeStake: bnStakeAmount.toString(),
+          unstakeBalance: '0',
+          status: _types.EarningStatus.EARNING_REWARD,
+          isBondedBefore: true,
+          nominations: delegatorState.map(delegate => ({
+            chain: this.chain,
+            validatorAddress: delegate.owner,
+            activeStake: delegate.amount,
+            status: _types.EarningStatus.EARNING_REWARD
+          })),
+          unstakings: []
+        });
+      });
+      await Promise.all(stakePromises);
+    };
+    const getMainnetPoolPosition = async () => {
+      const rawDelegateStateInfos = await Promise.all(useAddresses.map(address => fetchTaoDelegateState(address)));
+      if (rawDelegateStateInfos.length > 0) {
+        rawDelegateStateInfos.forEach((rawDelegateStateInfo, i) => {
+          const owner = (0, _utils2.reformatAddress)(useAddresses[i], 42);
+          const delegatorState = [];
+          let bnTotalBalance = _util.BN_ZERO;
+          const delegateStateInfo = rawDelegateStateInfo.items;
+          for (const delegate of delegateStateInfo) {
+            bnTotalBalance = bnTotalBalance.add(new _util.BN(delegate.balance));
+            delegatorState.push({
+              owner: delegate.delegate_address.ss58,
+              amount: delegate.balance.toString()
+            });
+          }
+          if (delegateStateInfo && delegateStateInfo.length > 0) {
+            this.parseNominatorMetadata(chainInfo, owner, delegatorState).then(nominatorMetadata => {
+              rsCallback({
+                ...defaultInfo,
+                ...nominatorMetadata,
+                address: owner,
+                type: this.type
+              });
+            }).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: []
+            });
+          }
+        });
+      }
+    };
+    const getStakingPositionInterval = async () => {
+      if (cancel) {
+        return;
+      }
+      if (this.chain === 'bittensor_devnet') {
+        await getDevnetPoolPosition();
+      } else {
+        await getMainnetPoolPosition();
+      }
+    };
+    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 _topValidator = testnetDelegate;
+    const validatorAddresses = Object.keys(_topValidator);
+    return validatorAddresses.map(address => {
+      return {
+        address: address,
+        totalStake: '0',
+        ownStake: '0',
+        otherStake: '0',
+        minBond: '0',
+        nominatorCount: 0,
+        commission: '0',
+        expectedReturn: 0,
+        blocked: false,
+        isVerified: false,
+        chain: this.chain,
+        isCrowded: false,
+        identity: address
+      };
+    });
+  }
+  async getMainnetPoolTargets() {
+    const _topValidator = await fetchDelegates();
+    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.validators;
+    const validatorAddresses = Object.keys(validatorList);
+    const results = await Promise.all(validatorAddresses.map(i => {
+      const address = validatorList[i].hot_key.ss58;
+      const bnTotalStake = new _util.BN(validatorList[i].amount);
+      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));
+
+      // let name = '';
+      // const delegateInfo = await this.fetchDelegatesInfo(address);
+
+      // name = delegateInfo.delegates[0]?.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: address // name
+      };
+    }));
+
+    return results;
+  }
+  async getPoolTargets() {
+    if (this.chain === 'bittensor_devnet') {
+      return this.getDevnetPoolTargets();
+    } else {
+      return this.getMainnetPoolTargets();
+    }
+  }
+
+  /* Get pool targets */
+
+  /* Join pool action */
+
+  async createJoinExtrinsic(data, positionInfo) {
+    let bondDest = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'Staked';
+    const {
+      amount,
+      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, binaryAmount);
+    return [extrinsic, {
+      slug: this.nativeToken.slug,
+      amount: '0'
+    }];
+  }
+
+  /* Join pool action */
+
+  /* Leave pool action */
+
+  async handleYieldUnstake(amount, address, selectedTarget) {
+    const apiPromise = await this.substrateApi.isReady;
+    const binaryAmount = new _util.BN(amount);
+    const poolPosition = await this.getPoolPosition(address);
+    if (!selectedTarget || !poolPosition) {
+      return Promise.reject(new _TransactionError.TransactionError(_types.BasicTxErrorType.INVALID_PARAMS));
+    }
+    const extrinsic = apiPromise.api.tx.subtensorModule.removeStake(selectedTarget, binaryAmount);
+    return [_KoniTypes.ExtrinsicType.STAKING_LEAVE_POOL, extrinsic];
+  }
+
+  /* Leave pool action */
+}
+exports.default = TaoNativeStakingPoolHandler;

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

@@ -72,6 +72,9 @@ class EarningService {
       if (_constants2._STAKING_CHAIN_GROUP.amplitude.includes(chain)) {
         handlers.push(new _handlers.AmplitudeNativeStakingPoolHandler(this.state, chain));
       }
+      if (_constants2._STAKING_CHAIN_GROUP.bittensor.includes(chain)) {
+        handlers.push(new _handlers.TaoNativeStakingPoolHandler(this.state, chain));
+      }
       if (_constants2._STAKING_CHAIN_GROUP.nominationPool.includes(chain)) {
         handlers.push(new _handlers.NominationPoolHandler(this.state, chain));
       }

package/cjs/services/earning-service/utils/index.js

@@ -5,6 +5,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.applyDecimal = applyDecimal;
 exports.calculateReward = calculateReward;
+exports.getTaoTotalStake = getTaoTotalStake;
 exports.isActionFromValidator = isActionFromValidator;
 exports.isNominationPool = exports.isNativeStakingPool = exports.isLiquidPool = exports.isLendingPool = void 0;
 exports.parseIdentity = parseIdentity;
@@ -116,6 +117,8 @@ function isActionFromValidator(stakingType, chain) {
     return true;
   } else if (_constants._STAKING_CHAIN_GROUP.para.includes(chain)) {
     return true;
+  } else if (_constants._STAKING_CHAIN_GROUP.bittensor.includes(chain)) {
+    return true;
   }
   return false;
 }
@@ -138,4 +141,14 @@ exports.isLendingPool = isLendingPool;
 function applyDecimal(bnNumber, decimals) {
   const bnDecimals = new _util.BN((10 ** decimals).toString());
   return bnNumber.div(bnDecimals);
+}
+function getTaoTotalStake(rawDelegateState) {
+  const nodeInfos = rawDelegateState.items;
+  const stakes = nodeInfos.map(stake => stake.balance);
+  let totalStake = BigInt(0);
+  for (const _stake of stakes) {
+    const stakeAmount = BigInt(_stake);
+    totalStake += stakeAmount;
+  }
+  return totalStake;
 }

package/cjs/services/keyring-service/context/handlers/Modify.js

@@ -121,14 +121,16 @@ class AccountModifyHandler extends _Base.AccountBaseHandler {
     } = _ref2;
     const modifyPairs = this.state.modifyPairs;
     const isUnified = this.state.isUnifiedAccount(proxyId);
+    const oldAccounts = Object.keys(this.state.accounts);
+    const afterDeleteAccounts = oldAccounts.filter(id => id !== proxyId);
     let addresses;
     if (!isUnified) {
       addresses = [proxyId];
     } else {
       addresses = Object.keys(modifyPairs).filter(address => modifyPairs[address].accountProxyId === proxyId);
-      this.state.deleteAccountProxy(proxyId);
-      this.parentService.eventRemoveAccount(proxyId);
     }
+    this.state.deleteAccountProxy(proxyId);
+    this.parentService.eventRemoveAccountProxy(proxyId);
     for (const address of addresses) {
       delete modifyPairs[address];
     }
@@ -137,7 +139,13 @@ class AccountModifyHandler extends _Base.AccountBaseHandler {
       _uiKeyring.keyring.forgetAccount(address);
     }
     await Promise.all(addresses.map(address => new Promise(resolve => this.state.removeAccountRef(address, resolve))));
-    this.state.saveCurrentAccountProxyId(_constants.ALL_ACCOUNT_KEY);
+
+    // Cannot use `this.state.accounts` because it is not completely updated yet
+    if (afterDeleteAccounts.length > 1) {
+      this.state.saveCurrentAccountProxyId(_constants.ALL_ACCOUNT_KEY);
+    } else {
+      this.state.saveCurrentAccountProxyId(afterDeleteAccounts[0]);
+    }
     return addresses;
   }
   tonGetAllTonWalletContractVersion(request) {

package/cjs/services/keyring-service/context/state.js

@@ -450,12 +450,11 @@ class AccountState {
     if (proxyId === _constants.ALL_ACCOUNT_KEY) {
       return allowGetAllAccount ? this.getAllAddresses() : [];
     }
-    const accountProxies = this._accountProxy.value;
-    const modifyPairs = this._modifyPair.value;
+    const accountProxies = this.accounts;
     if (!accountProxies[proxyId]) {
       return [proxyId];
     } else {
-      return Object.keys(modifyPairs).filter(address => modifyPairs[address].accountProxyId === proxyId);
+      return accountProxies[proxyId].accounts.map(account => account.address);
     }
   }
 

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

@@ -29,7 +29,7 @@ class KeyringService {
   eventInjectReady() {
     this.state.eventService.emit('inject.ready', true);
   }
-  eventRemoveAccount(proxyId) {
+  eventRemoveAccountProxy(proxyId) {
     this.state.eventService.emit('accountProxy.remove', proxyId);
   }
   updateKeyringState() {