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

package/services/nft-service/index.js

@@ -1,171 +1,239 @@
 // Copyright 2019-2022 @subwallet/extension-base authors & contributors
 // SPDX-License-Identifier: Apache-2.0
 
-import { _AssetType } from '@subwallet/chain-list/types';
-import { _getEvmChainId } from '@subwallet/extension-base/services/chain-service/utils';
-import { baseParseIPFSUrl } from '@subwallet/extension-base/utils';
-import { getKeypairTypeByAddress } from '@subwallet/keyring';
-import { EthereumKeypairTypes } from '@subwallet/keyring/types';
-import subwalletApiSdk from '@subwallet-monorepos/subwallet-services-sdk';
+import { ServiceStatus } from '@subwallet/extension-base/services/base/types';
+import { _isChainSupportEvmNft, _isChainSupportNativeNft, _isChainSupportWasmNft } from '@subwallet/extension-base/services/chain-service/utils';
+import { addLazy, createPromiseHandler, waitTimeout } from '@subwallet/extension-base/utils';
+import keyring from '@subwallet/ui-keyring';
+import { BehaviorSubject } from 'rxjs';
+import { MultiChainNftFetcher } from "./multi-chain-nft-fetcher.js";
+const INITIAL_NFT_STATE = {
+  nftData: {
+    total: 0,
+    nftList: []
+  },
+  nftCollections: []
+};
 
-/**
- * NFT detection service
- * Responsible for managing NFT detection jobs per address
- */
+// HIGH PRIORITY – no lazy
+const IMMEDIATE_EVENTS = ['account.updateCurrent', 'account.add', 'account.remove'];
 
-function mapSdkToNftItem(rawInstance, chain, collectionId, owner) {
-  var _rawInstance$token_ty, _rawInstance$token_ty2, _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;
-        } else if (lower === 'false') {
-          value = false;
-        }
-      }
-      properties[key] = value;
-      if (key.toLowerCase() === 'rarity') {
-        rarity = String(value);
-      }
-    } catch {}
-  }
-  const hasProperties = Object.keys(properties).length > 0;
-  const normalizedType = (_rawInstance$token_ty = rawInstance.token_type) === null || _rawInstance$token_ty === void 0 ? void 0 : (_rawInstance$token_ty2 = _rawInstance$token_ty.replace('-', '')) === null || _rawInstance$token_ty2 === void 0 ? void 0 : _rawInstance$token_ty2.toUpperCase();
+// LOW PRIORITY – lazy
+const LAZY_EVENTS = ['asset.updateState', 'chain.add'];
+export class NftService {
+  NFT_INTERVAL_TIME = 2 * 60 * 60 * 1000; // 2 hours
 
-  // Only support ERC721
-  if (normalizedType !== 'ERC721') {
-    return null;
-  }
-  return {
-    id: (_rawInstance$id = rawInstance.id) === null || _rawInstance$id === void 0 ? void 0 : _rawInstance$id.toString(),
-    chain,
-    collectionId,
-    owner: rawInstance.owner || owner,
-    originAsset: undefined,
-    name: metadata.name || `#${rawInstance.id}`,
-    image: baseParseIPFSUrl(image),
-    externalUrl: rawInstance.external_app_url || undefined,
-    rarity,
-    description: metadata.description || undefined,
-    properties: hasProperties ? properties : null,
-    type: normalizedType === 'ERC721' ? _AssetType.ERC721 : _AssetType.ERC721,
-    // currently only support ERC721
-    rmrk_ver: undefined,
-    onChainOption: undefined,
-    assetHubType: undefined
-  };
-}
-function mapSdkToCollection(raw, chain) {
-  var _raw$token_instances;
-  const token = raw.token || {};
-  return {
-    // must-have
-    collectionId: token.address_hash,
-    chain,
-    originAsset: undefined,
-    // optional
-    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
-  };
-}
-export default class NftService {
-  inProgress = new Set();
+  nftStateSubject = new BehaviorSubject(INITIAL_NFT_STATE);
+  nftState$ = this.nftStateSubject.asObservable();
+  isReloading = false;
+  startPromiseHandler = createPromiseHandler();
+  stopPromiseHandler = createPromiseHandler();
+  status = ServiceStatus.NOT_INITIALIZED;
+  get isStarted() {
+    return this.status === ServiceStatus.STARTED;
+  }
   constructor(state) {
     this.state = state;
+    this.multiChainFetcher = new MultiChainNftFetcher(state);
+  }
+  async init() {
+    this.status = ServiceStatus.INITIALIZING;
+    await this.state.eventService.waitKeyringReady;
+    await this.state.eventService.waitChainReady;
+    await this.loadCachedData();
+    this.status = ServiceStatus.INITIALIZED;
+    this.state.eventService.onLazy(this.handleEvents.bind(this));
+  }
+  async loadCachedData() {
+    const [nftData, collections] = await Promise.all([this.state.getNft(), this.state.getNftCollection()]);
+    this.nftStateSubject.next({
+      nftData: nftData || {
+        total: 0,
+        nftList: []
+      },
+      nftCollections: collections || []
+    });
+  }
+  async start() {
+    if (this.status === ServiceStatus.STOPPING) {
+      await this.waitForStopped();
+    }
+    if (this.isStarted || this.status === ServiceStatus.STARTING) {
+      return this.waitForStarted();
+    }
+    this.status = ServiceStatus.STARTING;
+    await this.refreshNftData();
+    this.status = ServiceStatus.STARTED;
+    this.startPromiseHandler.resolve();
+    this.startScanNft();
+  }
+  async stop() {
+    if (this.status === ServiceStatus.STARTING) {
+      await this.waitForStarted();
+    }
+    if (this.status === ServiceStatus.STOPPED || this.status === ServiceStatus.STOPPING) {
+      return this.waitForStopped();
+    }
+    this.status = ServiceStatus.STOPPING;
+    this.stopScanNft();
+    this.stopPromiseHandler.resolve();
+  }
+  waitForStarted() {
+    return this.startPromiseHandler.promise;
+  }
+  waitForStopped() {
+    return this.stopPromiseHandler.promise;
+  }
+  checkIfNftUpdateNeeded(events, eventTypes) {
+    if (!eventTypes.includes('chain.updateState')) {
+      return false;
+    }
+    const updatedChains = this.extractUpdatedChains(events);
+    return this.hasNftSupportedChainUpdate(updatedChains);
+  }
+  extractUpdatedChains(events) {
+    return events.filter(event => event.type === 'chain.updateState').map(event => event.data[0]);
   }
-  async fetchEvmCollectionsWithPreview(addresses) {
-    for (const address of addresses) {
-      const type = getKeypairTypeByAddress(address);
-      const typeValid = [...EthereumKeypairTypes].includes(type);
-      if (typeValid) {
-        if (this.inProgress.has(address)) {
-          console.log(`[NftService] ${address} already running`);
-          continue;
-        }
-        this.inProgress.add(address);
-        try {
-          const nftDetectionApi = subwalletApiSdk.nftDetectionApi;
-          if (!(nftDetectionApi !== null && nftDetectionApi !== void 0 && nftDetectionApi.getEvmNftCollectionsByAddress)) {
-            console.warn('[NftService] NftDetectionApi not available');
-            continue;
-          }
-          const rawData = await nftDetectionApi.getEvmNftCollectionsByAddress(address);
-          const allItems = [];
-          const allCollections = [];
-          for (const [chain, collections] of Object.entries(rawData)) {
-            if (!Array.isArray(collections)) {
-              continue;
-            }
-            for (const col of collections) {
-              const mappedCollection = mapSdkToCollection(col, chain);
-              allCollections.push(mappedCollection);
-              if (Array.isArray(col.token_instances)) {
-                const items = col.token_instances.map(inst => mapSdkToNftItem(inst, chain, mappedCollection.collectionId, address)).filter(i => Boolean(i));
-                allItems.push(...items);
-              }
-            }
-          }
-          await this.state.handleDetectedNftCollections(allCollections);
-          await this.state.handleDetectedNfts(address, allItems);
-        } catch (err) {
-          console.warn(`[NftService] detect error for ${address}`, err);
-        } finally {
-          this.inProgress.delete(address);
-        }
+  hasNftSupportedChainUpdate(updatedChains) {
+    if (updatedChains.length === 0) {
+      return false;
+    }
+    const chainInfoMap = this.state.getServiceInfo().chainInfoMap;
+    return updatedChains.some(chainSlug => {
+      const chainInfo = chainInfoMap[chainSlug];
+      return this.isChainNftSupported(chainInfo);
+    });
+  }
+  isChainNftSupported(chainInfo) {
+    return _isChainSupportNativeNft(chainInfo) || _isChainSupportEvmNft(chainInfo) || _isChainSupportWasmNft(chainInfo);
+  }
+  handleImmediateRefresh(address) {
+    this.state.resetNft(address);
+    this.refreshNftData().catch(console.error);
+  }
+  scheduleLazyRefresh(delay) {
+    addLazy('nft.refresh', () => {
+      if (!this.isReloading && this.isStarted) {
+        this.refreshNftData().catch(console.error);
       }
+    }, delay, undefined, true);
+  }
+  handleEvents(events, eventTypes) {
+    const LAZY_REFRESH_DELAY = 1800;
+    const address = this.state.keyringService.context.currentAccount.proxyId;
+    const hasImmediateEvent = IMMEDIATE_EVENTS.some(event => eventTypes.includes(event));
+    const hasLazyEvent = LAZY_EVENTS.some(event => eventTypes.includes(event));
+    const needsNftUpdate = this.checkIfNftUpdateNeeded(events, eventTypes);
+    if (hasImmediateEvent || needsNftUpdate) {
+      this.handleImmediateRefresh(address);
+      return;
+    }
+    if (hasLazyEvent) {
+      this.scheduleLazyRefresh(LAZY_REFRESH_DELAY);
     }
   }
-  async getFullNftInstancesByCollection(request) {
-    const {
-      chainInfo,
-      contractAddress,
-      owners
-    } = request;
-    const chainId = _getEvmChainId(chainInfo);
-    if (!contractAddress || !owners || !chainId) {
-      console.warn('[NftService] missing params for getFullNftInstancesByCollection');
+  async fetchFullListNftOfACollection(request) {
+    if (this.isReloading) {
       return false;
     }
     try {
-      const nftDetectionApi = subwalletApiSdk.nftDetectionApi;
-      if (!(nftDetectionApi !== null && nftDetectionApi !== void 0 && nftDetectionApi.getAllNftInstances)) {
-        console.warn('[NftService] getAllNftInstances not available');
-        return false;
-      }
-      const ownerList = Array.isArray(owners) ? owners : [owners];
-      for (const eachOwner of ownerList) {
-        try {
-          const instances = await nftDetectionApi.getAllNftInstances(contractAddress, eachOwner, chainId.toString());
-          if (!Array.isArray(instances)) {
-            continue;
-          }
-          console.log('FOR TESTER (before)', instances);
-          const nftList = instances.map(inst => mapSdkToNftItem(inst, chainInfo.slug, contractAddress, eachOwner)).filter(i => Boolean(i));
-          console.log('FOR TESTER (after)', nftList);
-          await this.state.handleDetectedNfts(eachOwner, nftList);
-        } catch (innerErr) {
-          console.warn(`[NftService] getAllNftInstances failed for ${eachOwner}`, innerErr);
-        }
-      }
+      const result = await this.multiChainFetcher.fetchFullListNftOfACollection(request);
+
+      // Persist DB
+      this.persistNftData({
+        items: result.items,
+        collections: result.collections
+      });
       return true;
-    } catch (err) {
-      console.error(`[NftDetectionService] getFullNftInstancesByCollection error for ${contractAddress}`, err);
+    } catch (e) {
+      console.error('[NftServiceV2] fetchFullListNftOfaCollection failed', e);
       return false;
     }
   }
+  async fetchNftDetail(request) {
+    if (this.isReloading) {
+      return null;
+    }
+    try {
+      const result = await this.multiChainFetcher.fetchNftDetail(request);
+      return result.items[0];
+    } catch (e) {
+      console.error('[NftServiceV2] fetchNftDetail failed', e);
+      return null;
+    }
+  }
+  startScanNft() {
+    this.stopScanNft();
+    const scanNft = () => {
+      if (!this.isStarted || this.isReloading) {
+        return;
+      }
+      this.refreshNftData().catch(console.error);
+    };
+    this._intervalFetchNft = setInterval(scanNft, this.NFT_INTERVAL_TIME);
+  }
+  stopScanNft() {
+    this._intervalFetchNft && clearInterval(this._intervalFetchNft);
+    this._intervalFetchNft = undefined;
+  }
+  persistNftData(result) {
+    try {
+      for (const item of result.items) {
+        const sender = keyring.getPair(item.owner);
+        this.state.updateNftData(item.chain, item, sender.address || item.owner);
+      }
+      for (const col of result.collections) {
+        this.state.setNftCollection(col.chain, col);
+      }
+    } catch (error) {
+      console.error('[NftServiceV2] Persist failed:', error);
+    }
+  }
+  async refreshNftData() {
+    if (this.isReloading) {
+      return;
+    }
+    this.isReloading = true;
+    try {
+      const addresses = this.state.keyringService.context.getDecodedAddresses();
+      const activeChains = Object.keys(this.state.getActiveChainInfoMap());
+      if (addresses.length === 0 || activeChains.length === 0) {
+        this.nftStateSubject.next(INITIAL_NFT_STATE);
+        return;
+      }
+      const result = await this.multiChainFetcher.fetch(addresses, activeChains);
+      this.persistNftData(result);
+      this.nftStateSubject.next({
+        nftData: {
+          total: result.items.length,
+          nftList: result.items
+        },
+        nftCollections: result.collections
+      });
+    } catch (error) {
+      console.error('[NftService] Refresh failed:', error);
+      this.nftStateSubject.next({
+        ...this.nftStateSubject.getValue()
+      });
+    } finally {
+      this.isReloading = false;
+    }
+  }
+
+  /** Subscribe NFT state */
+  subscribeNftItem() {
+    return this.nftState$;
+  }
+  subscribeNftCollection() {
+    const getChains = () => this.state.activeChainSlugs;
+    return this.state.dbService.stores.nftCollection.subscribeNftCollection(getChains);
+  }
+
+  // TODO: Move NFT reset logic to this function after migration is complete
+  async forceReload() {
+    this.isReloading = true;
+    await waitTimeout(1800);
+    this.isReloading = false;
+    await this.refreshNftData().catch(console.error);
+  }
 }

package/services/nft-service/multi-chain-nft-fetcher.d.ts

@@ -0,0 +1,13 @@
+import { NftDetailRequest, NftFullListRequest } from '@subwallet/extension-base/background/KoniTypes';
+import KoniState from '@subwallet/extension-base/koni/background/handlers/State';
+import { NftHandlerResult } from './nft-handlers/base-nft-handler';
+export declare class MultiChainNftFetcher {
+    private readonly state;
+    constructor(state: KoniState);
+    private handlerCache;
+    private getOrCreate;
+    private getHandlersForChain;
+    fetch(addresses: string[], chainSlugs: string[]): Promise<NftHandlerResult>;
+    fetchFullListNftOfACollection(request: NftFullListRequest): Promise<NftHandlerResult>;
+    fetchNftDetail(request: NftDetailRequest): Promise<NftHandlerResult>;
+}

package/services/nft-service/multi-chain-nft-fetcher.js

@@ -0,0 +1,138 @@
+// Copyright 2019-2022 @subwallet/extension-koni authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { NFT_HANDLER_REGISTRY } from '@subwallet/extension-base/services/nft-service/nft-handlers/registry';
+export class MultiChainNftFetcher {
+  constructor(state) {
+    this.state = state;
+  }
+  handlerCache = new Map();
+  getOrCreate(chain, desc) {
+    const key = `${chain}:${desc.id}`;
+    let handler = this.handlerCache.get(key);
+    if (!handler) {
+      handler = desc.create(chain, this.state);
+      this.handlerCache.set(key, handler);
+    }
+    return handler;
+  }
+  getHandlersForChain(chainSlug) {
+    const chainInfo = this.state.chainService.getChainInfoByKey(chainSlug);
+    if (!chainInfo) {
+      return [];
+    }
+    return NFT_HANDLER_REGISTRY.filter(d => d.supports(chainInfo)).map(d => this.getOrCreate(chainSlug, d));
+  }
+  async fetch(addresses, chainSlugs) {
+    const allItems = [];
+    const allCollections = [];
+    const tasks = [];
+    for (const chain of chainSlugs) {
+      const handlers = this.getHandlersForChain(chain);
+      if (handlers.length === 0) {
+        console.warn(`[NftFetcher] No handler for chain: ${chain}`);
+        continue;
+      }
+      for (const handler of handlers) {
+        const handlerAddresses = handler.filterAddresses(addresses);
+        const task = handler.fetchPreview(handlerAddresses).then(result => {
+          allItems.push(...result.items);
+          allCollections.push(...result.collections);
+        }).catch(err => {
+          console.error(`[NftFetcher] Handler failed on ${chain}: handler.id`, err);
+        });
+        tasks.push(task);
+      }
+    }
+    await Promise.all(tasks);
+
+    // DEDUPLICATE
+    // Todo: Move logic DEDUPLICATE to each handler
+    const seenItemIds = new Set();
+    const seenCollectionKeys = new Set();
+    const uniqueItems = [];
+    const uniqueCollections = [];
+    for (const item of allItems) {
+      if (!seenItemIds.has(item.id)) {
+        seenItemIds.add(item.id);
+        uniqueItems.push(item);
+      }
+    }
+    for (const col of allCollections) {
+      const key = `${col.chain}:${col.collectionId}`;
+      if (!seenCollectionKeys.has(key)) {
+        seenCollectionKeys.add(key);
+        uniqueCollections.push(col);
+      }
+    }
+    return {
+      items: uniqueItems,
+      collections: uniqueCollections
+    };
+  }
+  async fetchFullListNftOfACollection(request) {
+    const {
+      chainInfo,
+      collectionId,
+      owners,
+      tokenIds
+    } = request;
+    const items = [];
+    const collections = [];
+    const handlers = this.getHandlersForChain(chainInfo.slug);
+    for (const handler of handlers) {
+      // Todo: Improve the full-list fetch feature
+      // if (!handler.supportsFetchFullNftList) {
+      //   continue;
+      // }
+
+      const handlerOwners = handler.filterAddresses(owners);
+      try {
+        const result = await handler.fetchFullListNftOfACollection({
+          collectionId: collectionId,
+          owners: handlerOwners,
+          tokenIds: tokenIds,
+          chainInfo
+        });
+        items.push(...result.items);
+        collections.push(...result.collections);
+      } catch (e) {
+        console.error('[NftFetcher] fetchCollection failed', e);
+      }
+    }
+    return {
+      items,
+      collections
+    };
+  }
+  async fetchNftDetail(request) {
+    const {
+      chainSlug,
+      collectionId,
+      tokenId
+    } = request;
+    const items = [];
+    const collections = [];
+    const handlers = this.getHandlersForChain(chainSlug);
+    for (const handler of handlers) {
+      // Todo: Improve the detail nft fetch feature
+      // if (!handler.supportsFetchFullNftList) {
+      //   continue;
+      // }
+
+      try {
+        return await handler.fetchNftDetail({
+          collectionId: collectionId,
+          tokenId: tokenId,
+          chainSlug
+        });
+      } catch (e) {
+        console.error('[NftFetcher] fetchCollection failed', e);
+      }
+    }
+    return {
+      items,
+      collections
+    };
+  }
+}

package/services/nft-service/nft-handlers/base-nft-handler.d.ts

@@ -0,0 +1,13 @@
+import { NftCollection, NftDetailRequest, NftFullListRequest, NftItem } from '@subwallet/extension-base/background/KoniTypes';
+export interface NftHandlerResult {
+    items: NftItem[];
+    collections: NftCollection[];
+}
+export declare abstract class BaseNftHandler {
+    protected readonly chain: string;
+    constructor(chain: string);
+    abstract fetchPreview(addresses: string[]): Promise<NftHandlerResult>;
+    abstract filterAddresses(addresses: string[]): string[];
+    fetchFullListNftOfACollection(_request: NftFullListRequest): Promise<NftHandlerResult>;
+    fetchNftDetail(_request: NftDetailRequest): Promise<NftHandlerResult>;
+}

package/services/nft-service/nft-handlers/base-nft-handler.js

@@ -0,0 +1,21 @@
+// Copyright 2019-2022 @subwallet/extension-base authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+const EMPTY_NFT_RESULT = {
+  items: [],
+  collections: []
+};
+export class BaseNftHandler {
+  constructor(chain) {
+    this.chain = chain;
+  }
+  // Optional method - subclasses can choose to implement or not
+  fetchFullListNftOfACollection(_request) {
+    return Promise.resolve(EMPTY_NFT_RESULT);
+  }
+
+  // Optional method - subclasses can choose to implement or not
+  fetchNftDetail(_request) {
+    return Promise.resolve(EMPTY_NFT_RESULT);
+  }
+}

package/services/nft-service/nft-handlers/evm/evm-nft-handler.d.ts

@@ -0,0 +1,9 @@
+import { NftFullListRequest } from '@subwallet/extension-base/background/KoniTypes';
+import { BaseNftHandler, NftHandlerResult } from '../base-nft-handler';
+export declare class EvmNftHandler extends BaseNftHandler {
+    filterAddresses(addresses: string[]): string[];
+    private mapSdkToNftItem;
+    private mapSdkToCollection;
+    fetchPreview(addresses: string[]): Promise<NftHandlerResult>;
+    fetchFullListNftOfACollection(request: NftFullListRequest): Promise<NftHandlerResult>;
+}