@subwallet/extension-base 1.3.53-0 → 1.3.54-0

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

@@ -2,10 +2,11 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { AssetLogoMap, ChainLogoMap } from '@subwallet/chain-list';
+import { _ChainStatus } from '@subwallet/chain-list/types';
 import { LATEST_CHAIN_PATCH_FETCHING_INTERVAL, md5HashChainAsset, md5HashChainInfo } from '@subwallet/extension-base/services/chain-online-service/constants';
 import { filterAssetInfoMap } from '@subwallet/extension-base/services/chain-service';
 import { _ChainConnectionStatus } from '@subwallet/extension-base/services/chain-service/types';
-import { fetchPatchData, randomizeProvider } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isCustomAsset, _isCustomChain, _isEqualSmartContractAsset, fetchPatchData, randomizeProvider } from '@subwallet/extension-base/services/chain-service/utils';
 export class ChainOnlineService {
   constructor(chainService, settingService, eventService, dbService) {
     this.chainService = chainService;
@@ -14,6 +15,9 @@ export class ChainOnlineService {
     this.dbService = dbService;
     this.firstApplied = false;
   }
+  resetFirstApplied() {
+    this.firstApplied = false;
+  }
   validatePatchWithHash(latestPatch) {
     const {
       ChainAsset,
@@ -61,7 +65,7 @@ export class ChainOnlineService {
         providers: _providers,
         ...info
       } = _info;
-      const providers = Object.assign(((_rs$slug = rs[slug]) === null || _rs$slug === void 0 ? void 0 : _rs$slug.providers) || {}, _providers);
+      const providers = rs[slug] ? (_rs$slug = rs[slug]) === null || _rs$slug === void 0 ? void 0 : _rs$slug.providers : _providers;
       rs[slug] = {
         ...info,
         providers
@@ -69,6 +73,26 @@ export class ChainOnlineService {
     }
     return rs;
   }
+  checkExistedPredefinedChain(latestChainInfoMap, genesisHash, evmChainId) {
+    let duplicatedSlug = '';
+    if (genesisHash) {
+      for (const chainInfo of Object.values(latestChainInfoMap)) {
+        if (chainInfo.substrateInfo && chainInfo.substrateInfo.genesisHash === genesisHash) {
+          duplicatedSlug = chainInfo.slug;
+        }
+      }
+    } else if (evmChainId) {
+      for (const chainInfo of Object.values(latestChainInfoMap)) {
+        if (chainInfo.evmInfo && chainInfo.evmInfo.evmChainId === evmChainId) {
+          duplicatedSlug = chainInfo.slug;
+        }
+      }
+    }
+    return duplicatedSlug;
+  }
+  generateSlugForSmartContractAsset(originChain, assetType, symbol, contractAddress) {
+    return `${originChain}-${assetType}-${symbol}-${contractAddress}`;
+  }
   async handleLatestPatch(latestPatch) {
     try {
       var _await$this$settingSe;
@@ -88,31 +112,151 @@ export class ChainOnlineService {
       let assetRegistry = structuredClone(this.chainService.getAssetRegistry());
       const currentChainStateMap = structuredClone(this.chainService.getChainStateMap());
       const currentChainStatusMap = structuredClone(this.chainService.getChainStatusMap());
+      const assetSetting = structuredClone(await this.chainService.getAssetSettings());
+      const migratedAssetSetting = {};
       let addedChain = [];
+      const customChains = [];
+      const deprecatedChains = [];
+      const deprecatedChainMap = {};
+      const deprecatedAssets = [];
       if (isSafePatch && (!this.firstApplied || currentPatchVersion !== latestPatchVersion)) {
         this.firstApplied = true;
 
         // 2. merge data map
         if (latestChainInfo && Object.keys(latestChainInfo).length > 0) {
+          const storedChainSettings = await this.dbService.getAllChainStore();
+          const storedChainSettingMap = {};
+          storedChainSettings.forEach(chainStoredSetting => {
+            storedChainSettingMap[chainStoredSetting.slug] = chainStoredSetting;
+          });
+          if (storedChainSettings.length > 0) {
+            for (const [storedSlug, storedChainInfo] of Object.entries(storedChainSettingMap)) {
+              if (_isCustomChain(storedSlug)) {
+                var _storedChainInfo$subs, _storedChainInfo$evmI;
+                // Check if this custom chain duplicates any of the latest chainInfo from patch based on genesisHash (for Substrate) or EVM chain ID.
+                const duplicatedDefaultSlug = this.checkExistedPredefinedChain(latestChainInfo, (_storedChainInfo$subs = storedChainInfo.substrateInfo) === null || _storedChainInfo$subs === void 0 ? void 0 : _storedChainInfo$subs.genesisHash, (_storedChainInfo$evmI = storedChainInfo.evmInfo) === null || _storedChainInfo$evmI === void 0 ? void 0 : _storedChainInfo$evmI.evmChainId);
+                if (duplicatedDefaultSlug.length > 0) {
+                  // Add the old custom chain slug to the list of deprecated chains.
+                  deprecatedChainMap[storedSlug] = duplicatedDefaultSlug;
+                  deprecatedChains.push(storedSlug);
+                  const storedChainState = currentChainStateMap[storedSlug];
+                  const storedChainStatus = currentChainStatusMap[storedSlug];
+
+                  // Update the current chain state to use the new chain slug, inheriting the active/inactive status from custom chain and randomly assigning a provider
+                  currentChainStateMap[duplicatedDefaultSlug] = {
+                    slug: duplicatedDefaultSlug,
+                    active: storedChainState.active,
+                    currentProvider: randomizeProvider(latestChainInfo[duplicatedDefaultSlug].providers).providerKey,
+                    manualTurnOff: storedChainState.manualTurnOff
+                  };
+
+                  // Update the current chain status to use the new chain slug, inheriting the connection status from custom chain and updating the last updated timestamp
+                  currentChainStatusMap[duplicatedDefaultSlug] = {
+                    slug: duplicatedDefaultSlug,
+                    connectionStatus: storedChainStatus.connectionStatus,
+                    lastUpdated: Date.now()
+                  };
+                  customChains.push(duplicatedDefaultSlug);
+
+                  // Remove the deprecated custom chain's info from the old chain info map and the current state/status maps.
+                  delete oldChainInfoMap[storedSlug];
+                  delete currentChainStateMap[storedSlug];
+                  delete currentChainStatusMap[storedSlug];
+                }
+              }
+            }
+          }
           chainInfoMap = this.mergeChainList(oldChainInfoMap, latestChainInfo);
           const [currentChainStateKey, newChainKey] = [Object.keys(currentChainStateMap), Object.keys(chainInfoMap)];
-          addedChain = newChainKey.filter(chain => !currentChainStateKey.includes(chain));
+          addedChain = newChainKey.filter(chain => !currentChainStateKey.includes(chain) || customChains.includes(chain));
           addedChain.forEach(key => {
-            currentChainStateMap[key] = {
-              active: false,
-              currentProvider: randomizeProvider(chainInfoMap[key].providers).providerKey,
-              manualTurnOff: false,
-              slug: key
-            };
-            currentChainStatusMap[key] = {
-              slug: key,
-              connectionStatus: _ChainConnectionStatus.DISCONNECTED,
-              lastUpdated: Date.now()
-            };
+            if (!currentChainStateMap[key] && !currentChainStatusMap[key]) {
+              currentChainStateMap[key] = {
+                active: false,
+                currentProvider: randomizeProvider(chainInfoMap[key].providers).providerKey,
+                manualTurnOff: false,
+                slug: key
+              };
+              currentChainStatusMap[key] = {
+                slug: key,
+                connectionStatus: _ChainConnectionStatus.DISCONNECTED,
+                lastUpdated: Date.now()
+              };
+            }
           });
         }
         if (latestAssetInfo && Object.keys(latestAssetInfo).length > 0) {
-          assetRegistry = filterAssetInfoMap(oldChainInfoMap, Object.assign({}, oldAssetRegistry, latestAssetInfo), addedChain);
+          // Get all previously stored asset registry entries from the database.
+          const storedAssetRegistry = await this.dbService.getAllAssetStore();
+          const availableChains = Object.values(chainInfoMap).filter(info => info.chainStatus === _ChainStatus.ACTIVE).map(chainInfo => chainInfo.slug);
+          let finalAssetRegistry;
+          if (storedAssetRegistry.length === 0) {
+            finalAssetRegistry = oldAssetRegistry;
+          } else {
+            const mergedAssetRegistry = oldAssetRegistry;
+            const parsedStoredAssetRegistry = {};
+
+            // Update custom assets of merged custom chains
+            for (const storedAsset of Object.values(storedAssetRegistry)) {
+              var _storedAsset$metadata;
+              // If the stored asset is a custom asset and its origin chain is marked as deprecated, and its assetType is ERC20
+              if (_isCustomAsset(storedAsset.slug) && Object.keys(deprecatedChainMap).includes(storedAsset.originChain) && (_storedAsset$metadata = storedAsset.metadata) !== null && _storedAsset$metadata !== void 0 && _storedAsset$metadata.contractAddress) {
+                const newOriginChain = deprecatedChainMap[storedAsset.originChain];
+                // const newSlug = this.generateSlugForSmartContractAsset(newOriginChain, storedAsset.assetType, storedAsset.symbol, storedAsset.metadata?.contractAddress);
+
+                // Mark the old custom asset slug as deprecated.
+                deprecatedAssets.push(storedAsset.slug);
+                parsedStoredAssetRegistry[storedAsset.slug] = {
+                  ...storedAsset,
+                  originChain: newOriginChain
+                };
+              } else {
+                parsedStoredAssetRegistry[storedAsset.slug] = storedAsset;
+              }
+            }
+            for (const storedAssetInfo of Object.values(parsedStoredAssetRegistry)) {
+              let duplicated = false;
+              let deprecated = false;
+              let defaultSlugForMigration;
+              for (const defaultChainAsset of Object.values(latestAssetInfo)) {
+                // case: the stored asset is the same to a smart contract asset from patch
+                if (_isEqualSmartContractAsset(storedAssetInfo, defaultChainAsset)) {
+                  duplicated = true;
+                  defaultSlugForMigration = defaultChainAsset.slug;
+                  break;
+                }
+
+                // case: the origin chain of the stored asset is no longer active (Exp: custom chain is deprecated)
+                if (availableChains.indexOf(storedAssetInfo.originChain) === -1) {
+                  deprecated = true;
+                  defaultSlugForMigration = defaultChainAsset.slug;
+                  break;
+                }
+              }
+
+              // If the stored asset is a duplicate of a default asset or its origin chain is deprecated.
+              if (duplicated || deprecated) {
+                if (Object.keys(assetSetting).includes(storedAssetInfo.slug)) {
+                  const isVisible = assetSetting[storedAssetInfo.slug].visible;
+
+                  // Migrate assetSetting from custom token to token from patch
+                  if (defaultSlugForMigration) {
+                    migratedAssetSetting[defaultSlugForMigration] = {
+                      visible: isVisible
+                    };
+                    delete assetSetting[storedAssetInfo.slug];
+                  }
+                }
+                delete mergedAssetRegistry[storedAssetInfo.slug];
+                deprecatedAssets.push(storedAssetInfo.slug);
+              } else {
+                // If the stored asset is not a duplicate and its origin chain is active, keep it in the merged registry.
+                mergedAssetRegistry[storedAssetInfo.slug] = storedAssetInfo;
+              }
+            }
+            finalAssetRegistry = mergedAssetRegistry;
+          }
+          assetRegistry = filterAssetInfoMap(oldChainInfoMap, Object.assign({}, finalAssetRegistry, latestAssetInfo), addedChain);
         }
 
         // 3. validate data before write
@@ -130,6 +274,15 @@ export class ChainOnlineService {
           this.chainService.setChainStateMap(currentChainStateMap);
           this.chainService.subscribeChainStateMap().next(currentChainStateMap);
           this.chainService.subscribeChainStatusMap().next(currentChainStatusMap);
+          // Migrate assetSetting
+          this.chainService.setAssetSettings({
+            ...assetSetting,
+            ...migratedAssetSetting
+          });
+
+          // Remove all custom chains and custom tokens that is duplicated from chains or tokens in patch
+          await this.dbService.removeFromChainStore(deprecatedChains);
+          await this.dbService.removeFromAssetStore(deprecatedAssets);
           const storedChainInfoList = Object.keys(chainInfoMap).map(chainSlug => {
             return {
               ...chainInfoMap[chainSlug],

package/services/chain-service/index.js

@@ -1229,8 +1229,11 @@ export class ChainService {
   async initAssetRegistry(deprecatedCustomChainMap) {
     const storedAssetRegistry = await this.dbService.getAllAssetStore();
     const latestAssetRegistry = filterAssetInfoMap(this.getChainInfoMap(), ChainAssetMap);
+    const assetSetting = await this.getAssetSettings();
     const availableChains = Object.values(this.dataMap.chainInfoMap).filter(info => info.chainStatus === _ChainStatus.ACTIVE).map(chainInfo => chainInfo.slug);
+    const customChains = Object.keys(deprecatedCustomChainMap).filter(chain => _isCustomChain(chain));
     let finalAssetRegistry = {};
+    const migratedAssetSetting = {};
     if (storedAssetRegistry.length === 0) {
       finalAssetRegistry = latestAssetRegistry;
     } else {
@@ -1240,15 +1243,18 @@ export class ChainService {
 
       // Update custom assets of merged custom chains
       Object.values(storedAssetRegistry).forEach(storedAsset => {
-        if (_isCustomAsset(storedAsset.slug) && Object.keys(deprecatedCustomChainMap).includes(storedAsset.originChain)) {
-          var _storedAsset$metadata;
+        var _storedAsset$metadata;
+        const isFromCustomChain = customChains ? customChains.includes(storedAsset.originChain) : false;
+
+        // If the stored asset is a custom asset, from a deprecated custom chain, and has a contract address.
+        if (_isCustomAsset(storedAsset.slug) && isFromCustomChain && (_storedAsset$metadata = storedAsset.metadata) !== null && _storedAsset$metadata !== void 0 && _storedAsset$metadata.contractAddress) {
           const newOriginChain = deprecatedCustomChainMap[storedAsset.originChain];
-          const newSlug = this.generateSlugForSmartContractAsset(newOriginChain, storedAsset.assetType, storedAsset.symbol, (_storedAsset$metadata = storedAsset.metadata) === null || _storedAsset$metadata === void 0 ? void 0 : _storedAsset$metadata.contractAddress);
+          // const newSlug = this.generateSlugForSmartContractAsset(newOriginChain, storedAsset.assetType, storedAsset.symbol, storedAsset.metadata?.contractAddress);
+
           deprecatedAssets.push(storedAsset.slug);
-          parsedStoredAssetRegistry[newSlug] = {
+          parsedStoredAssetRegistry[storedAsset.slug] = {
             ...storedAsset,
-            originChain: newOriginChain,
-            slug: newSlug
+            originChain: newOriginChain
           };
         } else {
           parsedStoredAssetRegistry[storedAsset.slug] = storedAsset;
@@ -1257,25 +1263,48 @@ export class ChainService {
       for (const storedAssetInfo of Object.values(parsedStoredAssetRegistry)) {
         let duplicated = false;
         let deprecated = false;
+        let defaultSlugForMigration;
         for (const defaultChainAsset of Object.values(latestAssetRegistry)) {
-          // case merge custom asset with default asset
+          // Case: The stored asset is the same to a smart contract asset from new stable chainlist
           if (_isEqualSmartContractAsset(storedAssetInfo, defaultChainAsset)) {
             duplicated = true;
+            defaultSlugForMigration = defaultChainAsset.slug;
             break;
           }
+
+          // Case: If the origin chain of the stored asset is no longer active. (custom chain is deprecated)
           if (availableChains.indexOf(storedAssetInfo.originChain) === -1) {
             deprecated = true;
+            defaultSlugForMigration = defaultChainAsset.slug;
             break;
           }
+
+          // Case: If a default asset already exists with the same slug as the stored asset (from patch)
           if (defaultChainAsset.slug === storedAssetInfo.slug) {
             duplicated = true;
+            defaultSlugForMigration = defaultChainAsset.slug;
             break;
           }
         }
-        if (!duplicated && !deprecated) {
-          mergedAssetRegistry[storedAssetInfo.slug] = storedAssetInfo;
-        } else {
+
+        // If the stored asset is a duplicate of a default asset or its origin chain is deprecated.
+        if (duplicated || deprecated) {
+          if (Object.keys(assetSetting).includes(storedAssetInfo.slug)) {
+            const isVisible = assetSetting[storedAssetInfo.slug].visible;
+
+            // Migrate assetSetting from custom token to new default token
+            if (defaultSlugForMigration) {
+              migratedAssetSetting[defaultSlugForMigration] = {
+                visible: isVisible
+              };
+              delete assetSetting[storedAssetInfo.slug];
+            }
+          }
+          delete mergedAssetRegistry[storedAssetInfo.slug];
           deprecatedAssets.push(storedAssetInfo.slug);
+        } else {
+          // If the stored asset is not a duplicate and its origin chain is active, keep it in the merged registry.
+          mergedAssetRegistry[storedAssetInfo.slug] = storedAssetInfo;
         }
       }
       finalAssetRegistry = mergedAssetRegistry;

package/services/chain-service/utils/patch.d.ts

@@ -1,5 +1,5 @@
 import { _ChainAsset, _ChainInfo, _MultiChainAsset } from '@subwallet/chain-list/types';
-export declare const ChainListVersion = "0.2.111";
+export declare const ChainListVersion = "0.2.112";
 export interface PatchInfo {
     patchVersion: string;
     appliedVersion: string;

package/services/chain-service/utils/patch.js

@@ -3,9 +3,9 @@
 
 const PRODUCTION_BRANCHES = ['master', 'webapp', 'webapp-dev'];
 const branchName = process.env.BRANCH_NAME || 'subwallet-dev';
-const fetchDomain = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev';
+const fetchDomain = process.env.PATCH_CHAIN_LIST_URL || (PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'https://chain-list-assets.subwallet.app' : 'https://dev.sw-chain-list-assets.pages.dev');
 const fetchFile = PRODUCTION_BRANCHES.indexOf(branchName) > -1 ? 'list.json' : 'preview.json';
-export const ChainListVersion = '0.2.111'; // update this when build chain-list
+export const ChainListVersion = '0.2.112'; // update this when build chain-list
 
 // todo: move this interface to chainlist
 

package/services/earning-service/constants/chains.d.ts

@@ -23,4 +23,3 @@ export declare const MANTA_VALIDATOR_POINTS_PER_BLOCK = 20;
 export declare const MANTA_MIN_DELEGATION = 500;
 export declare const CHANNEL_ID = 7;
 export declare const STAKING_IDENTITY_API_SLUG: Record<string, string>;
-export declare const _SUPPORT_CHANGE_VALIDATOR_CHAIN: string[];

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

@@ -32,5 +32,4 @@ export const CHANNEL_ID = 7;
 export const STAKING_IDENTITY_API_SLUG = {
   polkadot: 'polkadot_people',
   kusama: 'peopleKusama'
-};
-export const _SUPPORT_CHANGE_VALIDATOR_CHAIN = ['polkadot', 'kusama'];
+};

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

@@ -3,8 +3,8 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import { ChainType, ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { _EvmApi, _SubstrateApi } from '@subwallet/extension-base/services/chain-service/types';
-import { BasePoolInfo, BaseYieldPoolMetadata, EarningRewardHistoryItem, EarningRewardItem, HandleYieldStepData, OptimalYieldPath, OptimalYieldPathParams, RequestEarlyValidateYield, RequestEarningSlippage, ResponseEarlyValidateYield, StakeCancelWithdrawalParams, SubmitChangeValidatorStaking, SubmitYieldJoinData, TransactionData, UnstakingInfo, YieldPoolInfo, YieldPoolMethodInfo, YieldPoolTarget, YieldPoolType, YieldPositionInfo, YieldStepBaseInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
-import { EarningSlippageResult } from './native-staking/dtao';
+import { BasePoolInfo, BaseYieldPoolMetadata, EarningRewardHistoryItem, EarningRewardItem, HandleYieldStepData, OptimalYieldPath, OptimalYieldPathParams, RequestEarlyValidateYield, RequestEarningImpact, ResponseEarlyValidateYield, StakeCancelWithdrawalParams, SubmitChangeValidatorStaking, SubmitYieldJoinData, TransactionData, UnstakingInfo, YieldPoolInfo, YieldPoolMethodInfo, YieldPoolTarget, YieldPoolType, YieldPositionInfo, YieldStepBaseInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
+import { EarningImpactResult } from './native-staking/dtao';
 /**
  * @class BasePoolHandler
  * @description Base pool handler
@@ -120,5 +120,5 @@ export default abstract class BasePoolHandler {
     abstract handleChangeEarningValidator(data: SubmitChangeValidatorStaking): Promise<TransactionData>;
     /** Check handler can handle slug */
     canHandleSlug(slug: string): boolean;
-    getEarningSlippage(params: RequestEarningSlippage): Promise<EarningSlippageResult>;
+    getEarningImpact(params: RequestEarningImpact): Promise<EarningImpactResult>;
 }

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

@@ -280,7 +280,7 @@ export default class BasePoolHandler {
   canHandleSlug(slug) {
     return this.slug === slug;
   }
-  getEarningSlippage(params) {
+  getEarningImpact(params) {
     return Promise.resolve({
       slippage: 0,
       rate: 1

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

@@ -131,7 +131,8 @@ export default class BaseNativeStakingPoolHandler extends BasePoolHandler {
       address,
       amount,
       selectedValidators,
-      slug
+      slug,
+      subnetData
     } = data;
     const positionInfo = await this.getPoolPosition(address, slug);
     const [extrinsic] = await this.createJoinExtrinsic(data, positionInfo);
@@ -140,7 +141,8 @@ export default class BaseNativeStakingPoolHandler extends BasePoolHandler {
       slug: this.slug,
       amount,
       address,
-      selectedValidators
+      selectedValidators,
+      subnetData
     };
     return {
       txChain: this.chain,

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

@@ -1,6 +1,6 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
-import { BaseYieldPositionInfo, RequestEarningSlippage, YieldPoolInfo, YieldPoolType, YieldPositionInfo } from '@subwallet/extension-base/types';
+import { BaseYieldPositionInfo, RequestEarningImpact, YieldPoolInfo, YieldPoolType, YieldPositionInfo } from '@subwallet/extension-base/types';
 import TaoNativeStakingPoolHandler, { TaoStakingStakeOption } from './tao';
 export interface SubnetData {
     netuid: number;
@@ -20,9 +20,10 @@ export interface RawDelegateState {
         stake: string;
     }>;
 }
-export interface EarningSlippageResult {
+export interface EarningImpactResult {
     slippage: number;
     rate: number;
+    stakingTaoFee?: string;
 }
 export default class SubnetTaoStakingPoolHandler extends TaoNativeStakingPoolHandler {
     readonly type = YieldPoolType.SUBNET_STAKING;
@@ -33,7 +34,7 @@ export default class SubnetTaoStakingPoolHandler extends TaoNativeStakingPoolHan
     private isInit;
     constructor(state: KoniState, chain: string);
     canHandleSlug(slug: string): boolean;
-    getEarningSlippage(params: RequestEarningSlippage): Promise<EarningSlippageResult>;
+    getEarningImpact(params: RequestEarningImpact): Promise<EarningImpactResult>;
     private init;
     protected getDescription(): string;
     subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;

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

@@ -41,7 +41,7 @@ export default class SubnetTaoStakingPoolHandler extends TaoNativeStakingPoolHan
   canHandleSlug(slug) {
     return slug.startsWith(`${this.slug}__`);
   }
-  async getEarningSlippage(params) {
+  async getEarningImpact(params) {
     const substrateApi = await this.substrateApi.isReady;
     const subnetInfo = (await substrateApi.api.call.subnetInfoRuntimeApi.getDynamicInfo(params.netuid)).toJSON();
     const alphaIn = new BigN((subnetInfo === null || subnetInfo === void 0 ? void 0 : subnetInfo.alphaIn) || 0);
@@ -49,15 +49,18 @@ export default class SubnetTaoStakingPoolHandler extends TaoNativeStakingPoolHan
     const k = alphaIn.multipliedBy(taoIn);
     const value = new BigN(params.value);
     const rate = taoIn.dividedBy(alphaIn);
+    const feeRate = await this.bittensorCache.fetchSubnetFeeRate(params.netuid);
     if (params.type === ExtrinsicType.STAKING_BOND) {
       const newTaoIn = taoIn.plus(value);
       const newAlphaIn = k.dividedBy(newTaoIn);
       const alphaReturned = alphaIn.minus(newAlphaIn);
       const alphaIdeal = value.multipliedBy(alphaIn).dividedBy(taoIn);
       const slippage = alphaIdeal.minus(alphaReturned).dividedBy(alphaIdeal);
+      const bnStakingTaoFee = value.multipliedBy(feeRate);
       return {
         slippage: slippage.plus(0.0001).toNumber(),
-        rate: rate.toNumber()
+        rate: rate.toNumber(),
+        stakingTaoFee: bnStakingTaoFee.toString()
       };
     } else if (params.type === ExtrinsicType.STAKING_UNBOND) {
       const newAlphaIn = alphaIn.plus(value);
@@ -65,9 +68,12 @@ export default class SubnetTaoStakingPoolHandler extends TaoNativeStakingPoolHan
       const taoReturned = taoIn.minus(newTaoReserve);
       const taoIdeal = value.multipliedBy(taoIn).dividedBy(alphaIn);
       const slippage = taoIdeal.minus(taoReturned).dividedBy(taoIdeal);
+      const taoAmount = value.multipliedBy(rate);
+      const bnStakingTaoFee = taoAmount.multipliedBy(feeRate);
       return {
         slippage: slippage.plus(0.0001).toNumber(),
-        rate: rate.toNumber()
+        rate: rate.toNumber(),
+        stakingTaoFee: bnStakingTaoFee.toString()
       };
     }
     return {

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

@@ -2,14 +2,12 @@
 import { _ChainInfo } from '@subwallet/chain-list/types';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { ExtrinsicType, NominationInfo, UnstakingInfo } 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 { BaseYieldPositionInfo, OptimalYieldPath, PalletStakingNominations, PalletStakingStakingLedger, StakeCancelWithdrawalParams, SubmitChangeValidatorStaking, SubmitJoinNativeStaking, SubmitYieldJoinData, TransactionData, ValidatorInfo, YieldPoolInfo, YieldPoolMethodInfo, YieldPositionInfo, YieldTokenBaseInfo } from '@subwallet/extension-base/types';
 import { BN } from '@polkadot/util';
 import BaseNativeStakingPoolHandler from './base';
 export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPoolHandler {
     availableMethod: YieldPoolMethodInfo;
-    constructor(state: KoniState, chain: string);
     subscribePoolInfo(callback: (data: YieldPoolInfo) => void): Promise<VoidFunction>;
     parseNominatorMetadata(chainInfo: _ChainInfo, address: string, substrateApi: _SubstrateApi, ledger: PalletStakingStakingLedger, currentEra: string, minStake: BN): Promise<Omit<YieldPositionInfo, keyof BaseYieldPositionInfo>>;
     handleNominationsList(substrateApi: _SubstrateApi, chain: string, nominations: PalletStakingNominations, currentEra: string, address: string, maxNominatorRewardedPerValidator: number | undefined): Promise<NominationInfo[]>;

package/services/earning-service/handlers/native-staking/relay-chain.js

@@ -6,7 +6,7 @@ import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import { calculateAlephZeroValidatorReturn, calculateChainStakedReturnV2, calculateInflation, calculateTernoaValidatorReturn, calculateValidatorStakedReturn, getAvgValidatorEraReward, getCommission, getMaxValidatorErrorMessage, getMinStakeErrorMessage, getRelayBlockedValidatorList, getRelayEraRewardMap, getRelayMaxNominations, getRelayTopValidatorByPoints, getRelayValidatorPointsMap, getRelayWaitingValidatorList, getSupportedDaysByHistoryDepth } from '@subwallet/extension-base/koni/api/staking/bonding/utils';
 import { _STAKING_ERA_LENGTH_MAP } from '@subwallet/extension-base/services/chain-service/constants';
 import { _getChainSubstrateAddressPrefix } from '@subwallet/extension-base/services/chain-service/utils';
-import { _STAKING_CHAIN_GROUP, _SUPPORT_CHANGE_VALIDATOR_CHAIN, MaxEraRewardPointsEras } from '@subwallet/extension-base/services/earning-service/constants';
+import { _STAKING_CHAIN_GROUP, MaxEraRewardPointsEras } from '@subwallet/extension-base/services/earning-service/constants';
 import { applyDecimal, parseIdentity } from '@subwallet/extension-base/services/earning-service/utils';
 import { BasicTxErrorType, EarningStatus, StakingTxErrorType, UnstakingStatus } from '@subwallet/extension-base/types';
 import { balanceFormatter, formatNumber, reformatAddress } from '@subwallet/extension-base/utils';
@@ -22,17 +22,8 @@ export default class RelayNativeStakingPoolHandler extends BaseNativeStakingPool
     cancelUnstake: true,
     withdraw: true,
     claimReward: false,
-    changeValidator: false
+    changeValidator: true
   };
-  constructor(state, chain) {
-    super(state, chain);
-    if (_SUPPORT_CHANGE_VALIDATOR_CHAIN.includes(chain)) {
-      this.availableMethod = {
-        ...this.availableMethod,
-        changeValidator: true
-      };
-    }
-  }
   /* Subscribe pool info */
 
   async subscribePoolInfo(callback) {

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

@@ -80,6 +80,7 @@ export declare class BittensorCache {
     get(): Promise<ValidatorResponse>;
     private fetchData;
     fetchApr(netuid: number): Promise<ValidatorAprResponse>;
+    fetchSubnetFeeRate(netuid: number): Promise<string>;
 }
 export declare const getAlphaToTaoRate: (substrateApi: _SubstrateApi, netuid: number) => Promise<string>;
 export default class TaoNativeStakingPoolHandler extends BaseParaStakingPoolHandler {

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

@@ -10,6 +10,7 @@ import BaseParaStakingPoolHandler from '@subwallet/extension-base/services/earni
 import { BasicTxErrorType, EarningStatus, StakingTxErrorType, YieldPoolType } from '@subwallet/extension-base/types';
 import { ProxyServiceRoute } from '@subwallet/extension-base/types/environment';
 import { fetchFromProxyService, formatNumber, reformatAddress } from '@subwallet/extension-base/utils';
+import { fetchStaticCache } from '@subwallet/extension-base/utils/fetchStaticCache';
 import BigN from 'bignumber.js';
 import { t } from 'i18next';
 import { BehaviorSubject, combineLatest } from 'rxjs';
@@ -44,21 +45,12 @@ export class BittensorCache {
   }
   async fetchData() {
     try {
-      const resp = await fetchFromProxyService(ProxyServiceRoute.BITTENSOR, '/dtao/validator/latest/v1?limit=100', {
-        method: 'GET',
-        headers: {
-          'Content-Type': 'application/json'
-        }
+      const fetchData = await fetchStaticCache('earning/dtao/validator.json', {
+        data: {}
       });
-      if (!resp.ok) {
-        console.error('Fetch bittensor delegates fail:', resp.status);
-        return this.cache || {
-          data: []
-        };
-      }
-      const rawData = await resp.json();
+      const validators = Object.values(fetchData.data);
       const data = {
-        data: rawData.data.filter(validator => parseFloat(validator.root_stake) > 0)
+        data: validators.filter(validator => parseFloat(validator.root_stake) > 0)
       };
       this.cache = data;
       this.promise = null;
@@ -71,7 +63,8 @@ export class BittensorCache {
             this.cache = newData;
           }
         }).catch(console.error);
-      }, 60 * 2000);
+      }, 60 * 1000); // Cache 1 minute
+
       return data;
     } catch (error) {
       console.error(error);
@@ -102,6 +95,23 @@ export class BittensorCache {
       };
     }
   }
+  async fetchSubnetFeeRate(netuid) {
+    try {
+      var _subnet$fee_rate;
+      const resp = await fetchFromProxyService(ProxyServiceRoute.BITTENSOR, '/subnet/latest/v1', {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      });
+      const rawData = await resp.json();
+      const subnet = rawData.data.find(item => item.netuid === netuid);
+      return (_subnet$fee_rate = subnet === null || subnet === void 0 ? void 0 : subnet.fee_rate) !== null && _subnet$fee_rate !== void 0 ? _subnet$fee_rate : '0.0005';
+    } catch (error) {
+      console.error(error);
+      return '0.0005'; // Default fee rate if fetch fails
+    }
+  }
 }
 
 // export async function fetchTaoDelegateState (address: string): Promise<RawDelegateState> {

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

@@ -3,10 +3,10 @@ import { TransactionError } from '@subwallet/extension-base/background/errors/Tr
 import { ExtrinsicType } from '@subwallet/extension-base/background/KoniTypes';
 import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
 import { PersistDataServiceInterface, ServiceStatus, StoppableServiceInterface } from '@subwallet/extension-base/services/base/types';
-import { EarningRewardHistoryItem, EarningRewardItem, EarningRewardJson, HandleYieldStepData, HandleYieldStepParams, OptimalYieldPath, OptimalYieldPathParams, RequestEarlyValidateYield, RequestEarningSlippage, RequestStakeCancelWithdrawal, RequestStakeClaimReward, RequestYieldLeave, RequestYieldWithdrawal, ResponseEarlyValidateYield, SubmitChangeValidatorStaking, TransactionData, ValidateYieldProcessParams, YieldPoolInfo, YieldPoolTarget, YieldPositionInfo } from '@subwallet/extension-base/types';
+import { EarningRewardHistoryItem, EarningRewardItem, EarningRewardJson, HandleYieldStepData, HandleYieldStepParams, OptimalYieldPath, OptimalYieldPathParams, RequestEarlyValidateYield, RequestEarningImpact, RequestStakeCancelWithdrawal, RequestStakeClaimReward, RequestYieldLeave, RequestYieldWithdrawal, ResponseEarlyValidateYield, SubmitChangeValidatorStaking, TransactionData, ValidateYieldProcessParams, YieldPoolInfo, YieldPoolTarget, YieldPositionInfo } from '@subwallet/extension-base/types';
 import { PromiseHandler } from '@subwallet/extension-base/utils';
 import { BehaviorSubject } from 'rxjs';
-import { EarningSlippageResult } from './handlers/native-staking/dtao';
+import { EarningImpactResult } from './handlers/native-staking/dtao';
 import { BasePoolHandler } from './handlers';
 export declare const fetchPoolsData: () => Promise<Record<string, YieldPoolInfo>>;
 export default class EarningService implements StoppableServiceInterface, PersistDataServiceInterface {
@@ -107,7 +107,7 @@ export default class EarningService implements StoppableServiceInterface, Persis
     handleYieldWithdraw(params: RequestYieldWithdrawal): Promise<TransactionData>;
     handleYieldCancelUnstake(params: RequestStakeCancelWithdrawal): Promise<TransactionData>;
     handleYieldClaimReward(params: RequestStakeClaimReward): Promise<TransactionData>;
-    yieldGetEarningSlippage(params: RequestEarningSlippage): Promise<EarningSlippageResult>;
+    yieldGetEarningImpact(params: RequestEarningImpact): Promise<EarningImpactResult>;
     handleYieldChangeValidator(params: SubmitChangeValidatorStaking): Promise<TransactionData>;
     resetWallet(): Promise<void>;
 }