@subwallet/extension-base 1.3.79-1 → 1.3.81-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/price-service/coingecko.js

@@ -100,7 +100,7 @@ const getPriceMap = async function (priceIds) {
       var _response4;
       useBackupApi = true;
       try {
-        response = await fetch(`https://api-cache.subwallet.app/api/price/get?ids=${idStr}`);
+        response = await fetch(`${apiCacheDomain}/api/price/get?ids=${idStr}`);
       } catch (e) {}
       if (((_response4 = response) === null || _response4 === void 0 ? void 0 : _response4.status) !== 200) {
         try {

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/core/substrate/xcm-parser.js

@@ -31,7 +31,7 @@ function getAvailBridgeWarning() {
   return 'Cross-chain transfer of this token may take up to 90 minutes, and you’ll need to manually claim the funds on the destination network to complete the transfer. Do you still want to continue?';
 }
 function getPolygonBridgeWarning(originChainInfo) {
-  if (originChainInfo.slug === COMMON_CHAIN_SLUGS.ETHEREUM || originChainInfo.slug === COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA) {
+  if (originChainInfo.slug === COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA) {
     return 'Cross-chain transfer of this token may take up to 40 minutes. Do you still want to continue?';
   } else {
     return 'Cross-chain transfer of this token may take up to 3 hours, and you’ll need to manually claim the funds on the destination network to complete the transfer. Do you still want to continue?';

package/koni/api/contract-handler/utils/index.js

@@ -52,13 +52,10 @@ export function getAvailBridgeGatewayContract(chain) {
 export function isAvailBridgeGatewayContract(contractAddress) {
   return [AVAILBRIDGE_GATEWAY_ETHEREUM_CONTRACT_ADDRESS, AVAILBRIDGE_GATEWAY_SEPOLIA_CONTRACT_ADDRESS].includes(contractAddress);
 }
-const POLYGONBRIDGE_GATEWAY_ETHEREUM_CONTRACT_ADDRESS = '0x2a3DD3EB832aF982ec71669E178424b10Dca2EDe';
 const POLYGONBRIDGE_GATEWAY_SEPOLIA_CONTRACT_ADDRESS = '0x528e26b25a34a4A5d0dbDa1d57D318153d2ED582';
 export function getPolygonBridgeContract(chain) {
   if (chain === 'polygonzkEvm_cardona' || chain === COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA) {
     return POLYGONBRIDGE_GATEWAY_SEPOLIA_CONTRACT_ADDRESS;
-  } else if (chain === 'polygonZkEvm' || chain === COMMON_CHAIN_SLUGS.ETHEREUM) {
-    return POLYGONBRIDGE_GATEWAY_ETHEREUM_CONTRACT_ADDRESS;
   }
   throw new Error('Invalid chain');
 }

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

@@ -3,6 +3,7 @@
 
 import { Common } from '@ethereumjs/common';
 import { LegacyTransaction } from '@ethereumjs/tx';
+import { COMMON_CHAIN_SLUGS } from '@subwallet/chain-list';
 import { _AssetType } from '@subwallet/chain-list/types';
 import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
 import { withErrorLog } from '@subwallet/extension-base/background/handlers/helpers';
@@ -1150,7 +1151,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) => {
@@ -5159,6 +5163,9 @@ export default class KoniExtension {
     });
   }
   async getIsClaimedPolygonBridge(data) {
+    if (data.chainslug !== COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA) {
+      throw new Error('Polygon zkEVM Mainnet Beta has sunset. Please use Polygon official Ethereum claim flow.');
+    }
     const evmApi = this.#koniState.getEvmApi(data.chainslug);
     // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
     const isClaimed = await isClaimedPolygonBridge(data.chainslug, data.counter, data.sourceNetwork, evmApi);
@@ -5172,12 +5179,15 @@ export default class KoniExtension {
     } = data;
     const extrinsicType = ExtrinsicType.CLAIM_BRIDGE;
     let transaction = null;
-    const evmApi = this.#koniState.getEvmApi(chain);
     const metadata = notification.metadata;
+    if (metadata.bridgeType !== 'POS' && chain !== COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA) {
+      throw new Error('Polygon zkEVM Mainnet Beta has sunset. Please use Polygon official Ethereum claim flow.');
+    }
+    const evmApi = this.#koniState.getEvmApi(chain);
     const feeInfo = await this.#koniState.feeService.subscribeChainFee(getId(), chain, 'evm');
     if (metadata.bridgeType === 'POS') {
       transaction = await getClaimPosBridge(chain, notification, evmApi, feeInfo);
-    } else {
+    } else if (chain === COMMON_CHAIN_SLUGS.ETHEREUM_SEPOLIA) {
       transaction = await getClaimPolygonBridge(chain, notification, evmApi, feeInfo);
     }
     const chainType = ChainType.EVM;
@@ -5657,16 +5667,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)':