@subwallet/extension-base 1.3.79-1 → 1.3.80-0

package/cjs/services/nft-service/nft-handlers/evm/evm-nft-handler.js

@@ -0,0 +1,179 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.EvmNftHandler = void 0;
+var _types = require("@subwallet/chain-list/types");
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _utils2 = require("@subwallet/extension-base/utils");
+var _subwalletServicesSdk = _interopRequireDefault(require("@subwallet-monorepos/subwallet-services-sdk"));
+var _baseNftHandler = require("../base-nft-handler");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class EvmNftHandler extends _baseNftHandler.BaseNftHandler {
+  filterAddresses(addresses) {
+    return (0, _utils2.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.EVM]);
+  }
+  mapSdkToNftItem(rawInstance, collectionId, owner) {
+    var _rawInstance$token_ty, _rawInstance$id;
+    const metadata = rawInstance.metadata || {};
+    const image = metadata.image || rawInstance.image_url || rawInstance.media_url || '';
+    const attributes = Array.isArray(metadata.attributes) ? metadata.attributes : [];
+    let rarity;
+    const properties = {};
+    for (const attr of attributes) {
+      try {
+        var _attr$trait_type;
+        const key = (_attr$trait_type = attr.trait_type) === null || _attr$trait_type === void 0 ? void 0 : _attr$trait_type.trim();
+        if (!key) {
+          continue;
+        }
+        let value = attr.value;
+        if (typeof value === 'string') {
+          const lower = value.toLowerCase();
+          if (lower === 'true') {
+            value = true;
+          }
+          if (lower === 'false') {
+            value = false;
+          }
+        }
+        properties[key] = value;
+        if (key.toLowerCase() === 'rarity') {
+          rarity = String(value);
+        }
+      } catch {
+        // ignore
+      }
+    }
+    const normalizedType = (_rawInstance$token_ty = rawInstance.token_type) === null || _rawInstance$token_ty === void 0 ? void 0 : _rawInstance$token_ty.replace('-', '').toUpperCase();
+    if (!['ERC721'].includes(normalizedType)) {
+      return null;
+    }
+    return {
+      id: ((_rawInstance$id = rawInstance.id) === null || _rawInstance$id === void 0 ? void 0 : _rawInstance$id.toString()) || '',
+      chain: this.chain,
+      collectionId,
+      owner: rawInstance.owner || owner,
+      name: metadata.name || `#${rawInstance.id}`,
+      image: (0, _utils2.baseParseIPFSUrl)(image),
+      externalUrl: rawInstance.external_app_url || undefined,
+      rarity,
+      description: metadata.description || undefined,
+      properties: Object.keys(properties).length > 0 ? properties : null,
+      type: normalizedType === 'ERC721' ? _types._AssetType.ERC721 : _types._AssetType.ERC721,
+      originAsset: undefined,
+      rmrk_ver: undefined,
+      onChainOption: undefined,
+      assetHubType: undefined
+    };
+  }
+  mapSdkToCollection(raw) {
+    var _raw$token_instances;
+    const token = raw.token || {};
+    return {
+      collectionId: token.address_hash,
+      chain: this.chain,
+      collectionName: token.name || token.symbol || 'Unknown Collection',
+      image: token.icon_url || undefined,
+      itemCount: Number(raw.amount) || ((_raw$token_instances = raw.token_instances) === null || _raw$token_instances === void 0 ? void 0 : _raw$token_instances.length) || 0,
+      externalUrl: undefined,
+      originAsset: undefined
+    };
+  }
+
+  // ==================== 1. PREVIEW – Used for cron / background ====================
+  async fetchPreview(addresses) {
+    const items = [];
+    const collections = [];
+    const api = _subwalletServicesSdk.default.nftDetectionApi;
+    if (!(api !== null && api !== void 0 && api.getEvmNftCollectionsByAddress)) {
+      console.warn('[EvmNftHandler] Preview API not available');
+      return {
+        items,
+        collections
+      };
+    }
+    for (const address of addresses) {
+      try {
+        const rawData = await api.getEvmNftCollectionsByAddress(address);
+        for (const [chain, sdkCollections] of Object.entries(rawData)) {
+          if (chain !== this.chain || !Array.isArray(sdkCollections)) {
+            continue;
+          }
+          for (const col of sdkCollections) {
+            const collection = this.mapSdkToCollection(col);
+            collections.push(collection);
+            if (Array.isArray(col.token_instances)) {
+              const mapped = col.token_instances.map(inst => this.mapSdkToNftItem(inst, collection.collectionId, address)).filter(i => i !== null);
+              items.push(...mapped);
+            }
+          }
+        }
+      } catch (error) {
+        console.error(`[EvmNftHandler] Preview failed for ${address}`, error);
+      }
+    }
+    return {
+      items: items,
+      collections: collections
+    };
+  }
+
+  // ==================== 2. FULL – At collection details screen ====================
+  async fetchFullListNftOfACollection(request) {
+    const items = [];
+    const collections = [];
+    const {
+      chainInfo,
+      collectionId,
+      owners
+    } = request;
+    const chainId = (0, _utils._getEvmChainId)(chainInfo);
+    if (!collectionId || !owners || !chainId) {
+      console.warn('[NftService] missing params for getFullNftInstancesByCollection');
+      return {
+        items,
+        collections
+      };
+    }
+    try {
+      const nftDetectionApi = _subwalletServicesSdk.default.nftDetectionApi;
+      if (!(nftDetectionApi !== null && nftDetectionApi !== void 0 && nftDetectionApi.getAllNftInstances)) {
+        console.warn('[NftService] getAllNftInstances not available');
+        return {
+          items,
+          collections
+        };
+      }
+      const ownerList = Array.isArray(owners) ? owners : [owners];
+      for (const eachOwner of ownerList) {
+        try {
+          const instances = await nftDetectionApi.getAllNftInstances(collectionId, eachOwner, chainId.toString());
+          if (!Array.isArray(instances)) {
+            continue;
+          }
+          const mappedItems = instances.map(inst => this.mapSdkToNftItem(inst, collectionId, eachOwner)).filter(i => Boolean(i));
+          items.push(...mappedItems);
+        } catch (innerErr) {
+          console.warn(`[NftService] getAllNftInstances failed for ${eachOwner}`, innerErr);
+        }
+      }
+    } catch (err) {
+      console.error(`[NftDetectionService] getFullNftInstancesByCollection error for ${collectionId}`, err);
+      return {
+        items: [],
+        collections: []
+      };
+    }
+    return {
+      items: items,
+      collections: collections
+    };
+  }
+}
+exports.EvmNftHandler = EvmNftHandler;

package/cjs/services/nft-service/nft-handlers/registry.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NFT_HANDLER_REGISTRY = void 0;
+exports.isNftV2Chain = isNftV2Chain;
+var _constants = require("@subwallet/extension-base/services/chain-service/constants");
+var _utils = require("@subwallet/extension-base/services/chain-service/utils");
+var _evmNftHandler = require("@subwallet/extension-base/services/nft-service/nft-handlers/evm/evm-nft-handler");
+var _uniqueNftHandler = require("@subwallet/extension-base/services/nft-service/nft-handlers/unique/unique-nft-handler");
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+function isNftV2Chain(chainInfo, registry) {
+  return registry.some(desc => desc.supports(chainInfo));
+}
+
+// todo list: only update into when migration
+const NFT_HANDLER_REGISTRY = [{
+  id: 'evm',
+  supports: chainInfo => (0, _utils._isChainSupportEvmNft)(chainInfo),
+  supportsFetchFullNftList: true,
+  create: chain => new _evmNftHandler.EvmNftHandler(chain)
+}, {
+  id: 'unique_network',
+  supports: chainInfo => _constants.NFT_CHAIN_GROUPS_MIGRATED.unique_network.includes(chainInfo.slug),
+  supportsFetchFullNftList: false,
+  create: chain => new _uniqueNftHandler.UniqueNftHandler(chain)
+}
+// {
+//   id: 'ordinal',
+//   supports: (chainInfo) => _isSupportOrdinal(chainInfo.slug),
+//   create: (chain, state) => new OrdinalNftHandler(chain, state)
+// }
+];
+exports.NFT_HANDLER_REGISTRY = NFT_HANDLER_REGISTRY;

package/cjs/services/nft-service/nft-handlers/unique/unique-nft-handler.js

@@ -0,0 +1,187 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UniqueNftHandler = void 0;
+var _KoniTypes = require("@subwallet/extension-base/background/KoniTypes");
+var _utils = require("@subwallet/extension-base/utils");
+var _subwalletServicesSdk = _interopRequireDefault(require("@subwallet-monorepos/subwallet-services-sdk"));
+var _baseNftHandler = require("../base-nft-handler");
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+class UniqueNftHandler extends _baseNftHandler.BaseNftHandler {
+  filterAddresses(addresses) {
+    return (0, _utils.getAddressesByChainType)(addresses, [_KoniTypes.ChainType.SUBSTRATE]);
+  }
+  mapUniqueCollections(raws) {
+    var _raws$collectionCover;
+    return {
+      collectionId: raws.collectionId.toString(),
+      chain: this.chain,
+      collectionName: raws.collectionName || 'Unknown Collection',
+      image: ((_raws$collectionCover = raws.collectionCover) === null || _raws$collectionCover === void 0 ? void 0 : _raws$collectionCover.url) || undefined,
+      externalUrl: undefined,
+      originAsset: undefined
+    };
+  }
+  mapUniqueRootNftToItem(raw, owner) {
+    return {
+      id: raw.tokenId.toString(),
+      chain: this.chain,
+      collectionId: raw.collectionId.toString(),
+      name: raw.name || `#${raw.tokenId}`,
+      image: raw.image || undefined,
+      description: raw.description || undefined,
+      owner: owner,
+      isBundle: false,
+      properties: null
+    };
+  }
+  mapBundleTreeToNftItem(node, topmostOwner) {
+    let level = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    let parentId = arguments.length > 3 ? arguments[3] : undefined;
+    const item = {
+      id: node.tokenId.toString(),
+      chain: this.chain,
+      collectionId: node.collectionId.toString(),
+      name: node.name || `#${node.tokenId}`,
+      image: node.image || undefined,
+      description: node.description || undefined,
+      owner: topmostOwner,
+      isBundle: node.nested && node.nested.length > 0 && level === 0,
+      properties: null,
+      nestingLevel: level,
+      parentId: level > 0 ? parentId : undefined
+    };
+    if (node.nested && node.nested.length > 0) {
+      item.nestingTokens = node.nested.map(child => this.mapBundleTreeToNftItem(child, topmostOwner, level + 1, item.id));
+    }
+    return item;
+  }
+  async fetchNftBundle(collectionId, tokenId, topmostOwner) {
+    const api = _subwalletServicesSdk.default.uniqueNftDetectionApi;
+    if (!api) {
+      return null;
+    }
+    try {
+      const treeData = await api.getNftBundleTree(collectionId, tokenId);
+      if (!treeData) {
+        return null;
+      }
+      return this.mapBundleTreeToNftItem(treeData, topmostOwner, 0, tokenId);
+    } catch (e) {
+      console.error('[UniqueNftHandler] Failed to fetch bundle tree', e);
+      return null;
+    }
+  }
+
+  // ==================== MAIN HANDLER ====================
+
+  async fetchPreview(addresses) {
+    const items = [];
+    const collectionsMap = new Map();
+    const api = _subwalletServicesSdk.default.uniqueNftDetectionApi;
+    if (!api) {
+      return {
+        items: [],
+        collections: []
+      };
+    }
+    try {
+      await Promise.all(addresses.map(async address => {
+        // 1. Collections
+        const sdkCollections = await api.getUniqueCollectionsByTokenOwner(address);
+        for (const col of sdkCollections) {
+          const collection = this.mapUniqueCollections(col);
+          if (!collectionsMap.has(collection.collectionId)) {
+            collectionsMap.set(collection.collectionId, collection);
+          }
+        }
+
+        // 2. Root NFTs
+        const sdkNfts = await api.getAllUniqueRootNfts({
+          owner: address
+        });
+        for (const rootNft of sdkNfts) {
+          items.push(this.mapUniqueRootNftToItem(rootNft, address));
+        }
+      }));
+    } catch (e) {
+      console.error(`[UniqueNftHandler] Failed to fetch for ${this.chain}`, e);
+    }
+    return {
+      items,
+      collections: Array.from(collectionsMap.values())
+    };
+  }
+  async fetchFullListNftOfACollection(request) {
+    const items = [];
+    const collections = [];
+    const {
+      collectionId,
+      owners,
+      tokenIds
+    } = request;
+    if (!collectionId || !owners || !tokenIds) {
+      console.warn('[NftService] missing params for getFullNftInstancesByCollection');
+      return {
+        items,
+        collections
+      };
+    }
+    for (const id of tokenIds) {
+      const fullTree = await this.fetchNftBundle(collectionId, id, owners[0]);
+      if (fullTree) {
+        items.push(fullTree);
+      }
+    }
+    return {
+      items: items,
+      collections: collections
+    };
+  }
+  async fetchNftDetail(request) {
+    const items = [];
+    const collections = [];
+    const api = _subwalletServicesSdk.default.uniqueNftDetectionApi;
+    if (!api) {
+      return {
+        items: [],
+        collections: []
+      };
+    }
+    const {
+      collectionId,
+      tokenId
+    } = request;
+    if (!collectionId || !tokenId) {
+      return {
+        items,
+        collections
+      };
+    }
+    try {
+      const rawNft = await api.getNftDetail(collectionId, tokenId);
+      if (!rawNft) {
+        return {
+          items: [],
+          collections: []
+        };
+      }
+      const nftItem = this.mapUniqueRootNftToItem(rawNft, rawNft.owner);
+      return {
+        items: [nftItem],
+        collections: []
+      };
+    } catch (e) {
+      return {
+        items: [],
+        collections: []
+      };
+    }
+  }
+}
+exports.UniqueNftHandler = UniqueNftHandler;

package/cjs/services/storage-service/DatabaseService.js

@@ -404,7 +404,7 @@ class DatabaseService {
     return this.stores.nft.removeNfts(chain, address, collectionId, nftIds);
   }
   removeNftsByAddress(address) {
-    return this.stores.nft.removeNftsByAddress([address]);
+    return this.stores.nft.removeNftsByAddress(address);
   }
 
   // Chain

package/core/substrate/system-pallet.js

@@ -43,6 +43,9 @@ function _getAppliedExistentialDeposit(accountInfo, existentialDeposit, strictMo
   if (strictMode) {
     return bnExistentialDeposit;
   }
+  if (accountInfo.data.free.toString() === existentialDeposit) {
+    return BigInt(0);
+  }
   return _canAccountBeReaped(accountInfo) ? BigInt(0) : bnExistentialDeposit; // account for ED here will go better with max transfer logic
 }
 function _getSystemPalletTransferableV2(accountInfo, existentialDeposit, strictMode) {

package/koni/api/nft/index.js

@@ -14,7 +14,7 @@ import { UniqueNftApi } from '@subwallet/extension-base/koni/api/nft/unique_netw
 import { VaraNftApi } from '@subwallet/extension-base/koni/api/nft/vara_nft';
 import { WasmNftApi } from '@subwallet/extension-base/koni/api/nft/wasm_nft';
 import { _NFT_CHAIN_GROUP } from '@subwallet/extension-base/services/chain-service/constants';
-import { _isChainSupportEvmNft, _isChainSupportNativeNft, _isChainSupportWasmNft, _isSupportOrdinal } from '@subwallet/extension-base/services/chain-service/utils';
+import { _isChainSupportNativeNft, _isChainSupportWasmNft, _isSupportOrdinal } from '@subwallet/extension-base/services/chain-service/utils';
 import { getAddressesByChainType, targetIsWeb } from '@subwallet/extension-base/utils';
 import AssetHubNftsPalletApi from "./assethub_nft/index.js";
 import { RariNftApi } from "./rari/index.js";
@@ -33,8 +33,6 @@ function createSubstrateNftApi(chain, substrateApi, addresses) {
     return [new AssetHubUniquesPalletApi(substrateApi, substrateAddresses, chain), new AssetHubNftsPalletApi(substrateApi, substrateAddresses, chain)];
   } else if (_NFT_CHAIN_GROUP.statemint.includes(chain)) {
     return [new AssetHubUniquesPalletApi(substrateApi, substrateAddresses, chain), new AssetHubNftsPalletApi(substrateApi, substrateAddresses, chain)];
-  } else if (_NFT_CHAIN_GROUP.unique_network.includes(chain)) {
-    return [new UniqueNftApi(chain, substrateAddresses)];
   } else if (_NFT_CHAIN_GROUP.unique_evm.includes(chain)) {
     return [new UniqueNftApi(chain, evmAddresses)];
   } else if (_NFT_CHAIN_GROUP.bitcountry.includes(chain)) {
@@ -56,10 +54,6 @@ function createWasmNftApi(chain, apiProps, addresses) {
   const substrateAddresses = getAddressesByChainType(addresses, [ChainType.SUBSTRATE]);
   return new WasmNftApi(apiProps, substrateAddresses, chain);
 }
-function createWeb3NftApi(chain, evmApi, addresses) {
-  const evmAddresses = getAddressesByChainType(addresses, [ChainType.EVM]);
-  return new EvmNftApi(evmApi, evmAddresses, chain);
-}
 const createOrdinalApi = (chain, subscanChain, addresses) => {
   return new OrdinalNftApi(addresses, chain, subscanChain);
 };
@@ -128,14 +122,6 @@ export class NftHandler {
               }
             }
           }
-          if (_isChainSupportEvmNft(chainInfo)) {
-            if (this.evmApiMap[chain]) {
-              const handler = createWeb3NftApi(chain, this.evmApiMap[chain], evmAddresses);
-              if (handler) {
-                this.handlers.push(handler);
-              }
-            }
-          }
           if (chain === 'unique_evm') {
             const handlers = createSubstrateNftApi(chain, null, evmAddresses);
             if (handlers && !!handlers.length) {

package/koni/background/cron.d.ts

@@ -29,7 +29,6 @@ export declare class KoniCron {
     refreshNft: (address: string, apiMap: ApiMap, smartContractNfts: _ChainAsset[], chainInfoMap: Record<string, _ChainInfo>) => () => void;
     resetNft: (newAddress: string) => void;
     checkNetworkAvailable: (serviceInfo: ServiceInfo) => boolean;
-    detectEvmCollectionNft: (address: string) => () => void;
     reloadNft(): Promise<boolean>;
     reloadStaking(): Promise<boolean>;
     private needUpdateNft;

package/koni/background/cron.js

@@ -1,7 +1,7 @@
 // Copyright 2019-2022 @subwallet/extension-koni authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { CRON_NFT_DETECT_INTERVAL, CRON_REFRESH_CHAIN_STAKING_METADATA, CRON_REFRESH_MKT_CAMPAIGN_INTERVAL, CRON_REFRESH_NFT_INTERVAL, CRON_SYNC_MANTA_PAY } from '@subwallet/extension-base/constants';
+import { CRON_REFRESH_CHAIN_STAKING_METADATA, CRON_REFRESH_MKT_CAMPAIGN_INTERVAL, CRON_REFRESH_NFT_INTERVAL, CRON_SYNC_MANTA_PAY } from '@subwallet/extension-base/constants';
 import { _isChainSupportEvmNft, _isChainSupportNativeNft, _isChainSupportWasmNft } from '@subwallet/extension-base/services/chain-service/utils';
 import { waitTimeout } from '@subwallet/extension-base/utils';
 import { Subject } from 'rxjs';
@@ -87,7 +87,6 @@ export class KoniCron {
       // NFT
       (commonReload || needUpdateNft) && this.resetNft(address);
       (commonReload || needUpdateNft) && this.removeCron('refreshNft');
-      (commonReload || needUpdateNft) && this.removeCron('detectNft');
       commonReload && this.removeCron('refreshPoolingStakingReward');
       if (mktCampaignNeedReload) {
         this.removeCron('fetchMktCampaignData');
@@ -103,7 +102,6 @@ export class KoniCron {
       if (this.checkNetworkAvailable(serviceInfo)) {
         // only add cron jobs if there's at least 1 active network
         (commonReload || needUpdateNft) && this.addCron('refreshNft', this.refreshNft(address, serviceInfo.chainApiMap, this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap()), CRON_REFRESH_NFT_INTERVAL);
-        (commonReload || needUpdateNft) && this.addCron('detectNft', this.detectEvmCollectionNft(address), CRON_NFT_DETECT_INTERVAL);
         reloadMantaPay && this.addCron('syncMantaPay', this.syncMantaPay, CRON_SYNC_MANTA_PAY);
       }
     };
@@ -116,8 +114,6 @@ export class KoniCron {
     if (Object.keys(this.state.getSubstrateApiMap()).length !== 0 || Object.keys(this.state.getEvmApiMap()).length !== 0) {
       this.resetNft(currentAccountInfo.proxyId);
       this.addCron('refreshNft', this.refreshNft(currentAccountInfo.proxyId, this.state.getApiMap(), this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap()), CRON_REFRESH_NFT_INTERVAL);
-      this.addCron('detectNft', this.detectEvmCollectionNft(currentAccountInfo.proxyId), CRON_NFT_DETECT_INTERVAL);
-      // this.addCron('refreshStakingReward', this.refreshStakingReward(currentAccountInfo.address), CRON_REFRESH_STAKING_REWARD_INTERVAL);
       this.addCron('syncMantaPay', this.syncMantaPay, CRON_SYNC_MANTA_PAY);
     }
     this.status = 'running';
@@ -166,25 +162,12 @@ export class KoniCron {
   checkNetworkAvailable = serviceInfo => {
     return Object.keys(serviceInfo.chainApiMap.substrate).length > 0 || Object.keys(serviceInfo.chainApiMap.evm).length > 0;
   };
-  detectEvmCollectionNft = address => {
-    return () => {
-      let addresses = [];
-      addresses = this.state.keyringService.context.getDecodedAddresses();
-      if (!addresses.length) {
-        console.warn('[Cron] No decoded addresses found for ALL_ACCOUNT_KEY');
-        return;
-      }
-      this.state.nftDetectionService.fetchEvmCollectionsWithPreview(addresses).catch(err => console.warn(`[Cron] NFT detection failed for ${address}:`, err));
-    };
-  };
   async reloadNft() {
     const address = this.state.keyringService.context.currentAccount.proxyId;
     const serviceInfo = this.state.getServiceInfo();
     this.resetNft(address);
     this.removeCron('refreshNft');
-    this.removeCron('detectNft');
     this.addCron('refreshNft', this.refreshNft(address, serviceInfo.chainApiMap, this.state.getSmartContractNfts(), this.state.getActiveChainInfoMap()), CRON_REFRESH_NFT_INTERVAL);
-    this.addCron('detectNft', this.detectEvmCollectionNft(address), CRON_NFT_DETECT_INTERVAL);
     await waitTimeout(1800);
     return true;
   }

package/koni/background/handlers/Extension.d.ts

@@ -117,6 +117,7 @@ export default class KoniExtension {
     private getNft;
     private subscribeNft;
     private handleGetNftFullList;
+    private handleGetNftDetail;
     private getStakingReward;
     private subscribeStakingReward;
     private getStaking;

package/koni/background/handlers/Extension.js

@@ -1150,7 +1150,10 @@ export default class KoniExtension {
     return this.getNft();
   }
   async handleGetNftFullList(request) {
-    return this.#koniState.nftDetectionService.getFullNftInstancesByCollection(request);
+    return this.#koniState.nftService.fetchFullListNftOfACollection(request);
+  }
+  async handleGetNftDetail(request) {
+    return this.#koniState.nftService.fetchNftDetail(request);
   }
   getStakingReward() {
     return new Promise((resolve, reject) => {
@@ -5657,16 +5660,14 @@ export default class KoniExtension {
         return this.getCrowdloanContributions(request);
       case 'pri(crowdloan.getSubscription)':
         return this.subscribeCrowdloan(id, port);
-      case 'pri(nft.getNft)':
-        return await this.getNft();
       case 'pri(nft.getSubscription)':
         return await this.subscribeNft(id, port);
-      case 'pri(nftCollection.getNftCollection)':
-        return await this.getNftCollection();
       case 'pri(nftCollection.getSubscription)':
         return await this.subscribeNftCollection(id, port);
       case 'pri(nft.getFullList)':
         return await this.handleGetNftFullList(request);
+      case 'pri(nft.getNftdetail)':
+        return await this.handleGetNftDetail(request);
       case 'pri(staking.getStaking)':
         return this.getStaking();
       case 'pri(staking.getSubscription)':

package/koni/background/handlers/State.d.ts

@@ -20,7 +20,7 @@ import MigrationService from '@subwallet/extension-base/services/migration-servi
 import MintCampaignService from '@subwallet/extension-base/services/mint-campaign-service';
 import MktCampaignService from '@subwallet/extension-base/services/mkt-campaign-service';
 import { MultisigService } from '@subwallet/extension-base/services/multisig-service';
-import NftService from '@subwallet/extension-base/services/nft-service';
+import { NftService } from '@subwallet/extension-base/services/nft-service';
 import NotificationService from '@subwallet/extension-base/services/notification-service/NotificationService';
 import OpenGovService from '@subwallet/extension-base/services/open-gov';
 import { PriceService } from '@subwallet/extension-base/services/price-service';
@@ -48,6 +48,11 @@ export default class KoniState {
     private externalRequest;
     private crowdloanMap;
     private crowdloanSubject;
+    /**
+     * TODO: Remove this subject once NFT migration to the service layer is completed.
+     * The state manager should not handle the internal state of the NFT service.
+     * The NFT service will manage its own state independently.
+     */
     private nftSubject;
     private mantaPayConfigSubject;
     isMantaPayEnabled: boolean;
@@ -77,7 +82,7 @@ export default class KoniState {
     readonly mintCampaignService: MintCampaignService;
     readonly campaignService: CampaignService;
     readonly mktCampaignService: MktCampaignService;
-    readonly nftDetectionService: NftService;
+    readonly nftService: NftService;
     readonly buyService: BuyService;
     readonly earningService: EarningService;
     readonly feeService: FeeService;
@@ -273,6 +278,7 @@ export default class KoniState {
     onAccountAdd(): void;
     onAccountRemove(): void;
     reloadNft(): Promise<boolean>;
+    reloadNftV2(): Promise<void>;
     reloadStaking(): Promise<boolean>;
     reloadBalance(): Promise<boolean>;
     approvePassPhishingPage(_url: string): Promise<boolean>;