@unicitylabs/sphere-sdk 0.3.5 → 0.3.7

package/dist/impl/browser/index.js

@@ -36,7 +36,11 @@ var STORAGE_KEYS_GLOBAL = {
   /** Group chat: processed event IDs for deduplication */
   GROUP_CHAT_PROCESSED_EVENTS: "group_chat_processed_events",
   /** Group chat: last used relay URL (stale data detection) */
-  GROUP_CHAT_RELAY_URL: "group_chat_relay_url"
+  GROUP_CHAT_RELAY_URL: "group_chat_relay_url",
+  /** Cached token registry JSON (fetched from remote) */
+  TOKEN_REGISTRY_CACHE: "token_registry_cache",
+  /** Timestamp of last token registry cache update (ms since epoch) */
+  TOKEN_REGISTRY_CACHE_TS: "token_registry_cache_ts"
 };
 var STORAGE_KEYS_ADDRESS = {
   /** Pending transfers for this address */
@@ -112,6 +116,8 @@ var DEFAULT_BASE_PATH = "m/44'/0'/0'";
 var DEFAULT_DERIVATION_PATH = `${DEFAULT_BASE_PATH}/0/0`;
 var DEFAULT_ELECTRUM_URL = "wss://fulcrum.alpha.unicity.network:50004";
 var TEST_ELECTRUM_URL = "wss://fulcrum.alpha.testnet.unicity.network:50004";
+var TOKEN_REGISTRY_URL = "https://raw.githubusercontent.com/unicitynetwork/unicity-ids/refs/heads/main/unicity-ids.testnet.json";
+var TOKEN_REGISTRY_REFRESH_INTERVAL = 36e5;
 var TEST_NOSTR_RELAYS = [
   "wss://nostr-relay.testnet.unicity.network"
 ];
@@ -125,7 +131,8 @@ var NETWORKS = {
     nostrRelays: DEFAULT_NOSTR_RELAYS,
     ipfsGateways: DEFAULT_IPFS_GATEWAYS,
     electrumUrl: DEFAULT_ELECTRUM_URL,
-    groupRelays: DEFAULT_GROUP_RELAYS
+    groupRelays: DEFAULT_GROUP_RELAYS,
+    tokenRegistryUrl: TOKEN_REGISTRY_URL
   },
   testnet: {
     name: "Testnet",
@@ -133,7 +140,8 @@ var NETWORKS = {
     nostrRelays: TEST_NOSTR_RELAYS,
     ipfsGateways: DEFAULT_IPFS_GATEWAYS,
     electrumUrl: TEST_ELECTRUM_URL,
-    groupRelays: DEFAULT_GROUP_RELAYS
+    groupRelays: DEFAULT_GROUP_RELAYS,
+    tokenRegistryUrl: TOKEN_REGISTRY_URL
   },
   dev: {
     name: "Development",
@@ -141,7 +149,8 @@ var NETWORKS = {
     nostrRelays: TEST_NOSTR_RELAYS,
     ipfsGateways: DEFAULT_IPFS_GATEWAYS,
     electrumUrl: TEST_ELECTRUM_URL,
-    groupRelays: DEFAULT_GROUP_RELAYS
+    groupRelays: DEFAULT_GROUP_RELAYS,
+    tokenRegistryUrl: TOKEN_REGISTRY_URL
   }
 };
 var TIMEOUTS = {
@@ -156,6 +165,7 @@ var TIMEOUTS = {
   /** Sync interval */
   SYNC_INTERVAL: 6e4
 };
+var DEFAULT_MARKET_API_URL = "https://market-api.unicity.network";
 
 // impl/browser/storage/LocalStorageProvider.ts
 var LocalStorageProvider = class {
@@ -523,36 +533,61 @@ var IndexedDBTokenStorageProvider = class {
     return meta !== null;
   }
   async clear() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-    }
-    this.status = "disconnected";
-    const CLEAR_TIMEOUT = 1500;
-    const withTimeout = (promise, ms, label) => Promise.race([
-      promise,
-      new Promise(
-        (_, reject) => setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms)
-      )
-    ]);
-    const deleteDb = (name) => new Promise((resolve) => {
-      const req = indexedDB.deleteDatabase(name);
-      req.onsuccess = () => resolve();
-      req.onerror = () => resolve();
-      req.onblocked = () => resolve();
-    });
+    const dbNames = [this.dbName];
     try {
+      if (this.db) {
+        await this.clearStore(STORE_TOKENS);
+        await this.clearStore(STORE_META);
+        this.db.close();
+        this.db = null;
+      }
+      this.status = "disconnected";
       if (typeof indexedDB.databases === "function") {
-        const dbs = await withTimeout(
-          indexedDB.databases(),
-          CLEAR_TIMEOUT,
-          "indexedDB.databases()"
-        );
-        await Promise.all(
-          dbs.filter((db) => db.name?.startsWith(this.dbNamePrefix)).map((db) => deleteDb(db.name))
-        );
-      } else {
-        await deleteDb(this.dbName);
+        try {
+          const dbs = await Promise.race([
+            indexedDB.databases(),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error("timeout")), 1500)
+            )
+          ]);
+          for (const dbInfo of dbs) {
+            if (dbInfo.name && dbInfo.name.startsWith(this.dbNamePrefix) && dbInfo.name !== this.dbName) {
+              dbNames.push(dbInfo.name);
+              try {
+                const db = await new Promise((resolve, reject) => {
+                  const req = indexedDB.open(dbInfo.name, DB_VERSION);
+                  req.onsuccess = () => resolve(req.result);
+                  req.onerror = () => reject(req.error);
+                  req.onupgradeneeded = (e) => {
+                    const d = e.target.result;
+                    if (!d.objectStoreNames.contains(STORE_TOKENS)) d.createObjectStore(STORE_TOKENS, { keyPath: "id" });
+                    if (!d.objectStoreNames.contains(STORE_META)) d.createObjectStore(STORE_META);
+                  };
+                });
+                const clearTx = db.transaction([STORE_TOKENS, STORE_META], "readwrite");
+                clearTx.objectStore(STORE_TOKENS).clear();
+                clearTx.objectStore(STORE_META).clear();
+                await new Promise((resolve) => {
+                  clearTx.oncomplete = () => resolve();
+                  clearTx.onerror = () => resolve();
+                });
+                db.close();
+              } catch {
+              }
+            }
+          }
+        } catch {
+        }
+      }
+      for (const name of dbNames) {
+        try {
+          const req = indexedDB.deleteDatabase(name);
+          req.onerror = () => {
+          };
+          req.onblocked = () => {
+          };
+        } catch {
+        }
       }
       return true;
     } catch (err) {
@@ -1101,7 +1136,9 @@ import {
   EventKinds,
   hashNametag,
   NostrClient,
-  Filter
+  Filter,
+  isChatMessage,
+  isReadReceipt
 } from "@unicitylabs/nostr-js-sdk";
 
 // core/crypto.ts
@@ -1319,6 +1356,8 @@ var NostrTransportProvider = class {
   transferHandlers = /* @__PURE__ */ new Set();
   paymentRequestHandlers = /* @__PURE__ */ new Set();
   paymentRequestResponseHandlers = /* @__PURE__ */ new Set();
+  readReceiptHandlers = /* @__PURE__ */ new Set();
+  typingIndicatorHandlers = /* @__PURE__ */ new Set();
   broadcastHandlers = /* @__PURE__ */ new Map();
   eventCallbacks = /* @__PURE__ */ new Set();
   constructor(config) {
@@ -1570,6 +1609,18 @@ var NostrTransportProvider = class {
     const wrappedContent = senderNametag ? JSON.stringify({ senderNametag, text: content }) : content;
     const giftWrap = NIP17.createGiftWrap(this.keyManager, nostrRecipient, wrappedContent);
     await this.publishEvent(giftWrap);
+    const selfWrapContent = JSON.stringify({
+      selfWrap: true,
+      originalId: giftWrap.id,
+      recipientPubkey,
+      senderNametag,
+      text: content
+    });
+    const selfPubkey = this.keyManager.getPublicKeyHex();
+    const selfGiftWrap = NIP17.createGiftWrap(this.keyManager, selfPubkey, selfWrapContent);
+    this.publishEvent(selfGiftWrap).catch((err) => {
+      this.log("Self-wrap publish failed:", err);
+    });
     this.emitEvent({
       type: "message:sent",
       timestamp: Date.now(),
@@ -1668,6 +1719,37 @@ var NostrTransportProvider = class {
     this.paymentRequestResponseHandlers.add(handler);
     return () => this.paymentRequestResponseHandlers.delete(handler);
   }
+  // ===========================================================================
+  // Read Receipts
+  // ===========================================================================
+  async sendReadReceipt(recipientTransportPubkey, messageEventId) {
+    if (!this.keyManager) throw new Error("Not initialized");
+    const nostrRecipient = recipientTransportPubkey.length === 66 ? recipientTransportPubkey.slice(2) : recipientTransportPubkey;
+    const event = NIP17.createReadReceipt(this.keyManager, nostrRecipient, messageEventId);
+    await this.publishEvent(event);
+    this.log("Sent read receipt for:", messageEventId, "to:", nostrRecipient.slice(0, 16));
+  }
+  onReadReceipt(handler) {
+    this.readReceiptHandlers.add(handler);
+    return () => this.readReceiptHandlers.delete(handler);
+  }
+  // ===========================================================================
+  // Typing Indicators
+  // ===========================================================================
+  async sendTypingIndicator(recipientTransportPubkey) {
+    if (!this.keyManager) throw new Error("Not initialized");
+    const nostrRecipient = recipientTransportPubkey.length === 66 ? recipientTransportPubkey.slice(2) : recipientTransportPubkey;
+    const content = JSON.stringify({
+      type: "typing",
+      senderNametag: this.identity?.nametag
+    });
+    const event = NIP17.createGiftWrap(this.keyManager, nostrRecipient, content);
+    await this.publishEvent(event);
+  }
+  onTypingIndicator(handler) {
+    this.typingIndicatorHandlers.add(handler);
+    return () => this.typingIndicatorHandlers.delete(handler);
+  }
   /**
    * Resolve any identifier to full peer information.
    * Routes to the appropriate specific resolve method based on identifier format.
@@ -2121,11 +2203,74 @@ var NostrTransportProvider = class {
       const pm = NIP17.unwrap(event, this.keyManager);
       this.log("Gift wrap unwrapped, sender:", pm.senderPubkey?.slice(0, 16), "kind:", pm.kind);
       if (pm.senderPubkey === this.keyManager.getPublicKeyHex()) {
-        this.log("Skipping own message");
+        try {
+          const parsed = JSON.parse(pm.content);
+          if (parsed?.selfWrap && parsed.recipientPubkey) {
+            this.log("Self-wrap replay for recipient:", parsed.recipientPubkey?.slice(0, 16));
+            const message2 = {
+              id: parsed.originalId || pm.eventId,
+              senderTransportPubkey: pm.senderPubkey,
+              senderNametag: parsed.senderNametag,
+              recipientTransportPubkey: parsed.recipientPubkey,
+              content: parsed.text ?? "",
+              timestamp: pm.timestamp * 1e3,
+              encrypted: true,
+              isSelfWrap: true
+            };
+            for (const handler of this.messageHandlers) {
+              try {
+                handler(message2);
+              } catch (e) {
+                this.log("Self-wrap handler error:", e);
+              }
+            }
+            return;
+          }
+        } catch {
+        }
+        this.log("Skipping own non-self-wrap message");
         return;
       }
-      if (pm.kind !== EventKinds.CHAT_MESSAGE) {
-        this.log("Skipping non-chat message, kind:", pm.kind);
+      if (isReadReceipt(pm)) {
+        this.log("Read receipt from:", pm.senderPubkey?.slice(0, 16), "for:", pm.replyToEventId);
+        if (pm.replyToEventId) {
+          const receipt = {
+            senderTransportPubkey: pm.senderPubkey,
+            messageEventId: pm.replyToEventId,
+            timestamp: pm.timestamp * 1e3
+          };
+          for (const handler of this.readReceiptHandlers) {
+            try {
+              handler(receipt);
+            } catch (e) {
+              this.log("Read receipt handler error:", e);
+            }
+          }
+        }
+        return;
+      }
+      try {
+        const parsed = JSON.parse(pm.content);
+        if (parsed?.type === "typing") {
+          this.log("Typing indicator from:", pm.senderPubkey?.slice(0, 16));
+          const indicator = {
+            senderTransportPubkey: pm.senderPubkey,
+            senderNametag: parsed.senderNametag,
+            timestamp: pm.timestamp * 1e3
+          };
+          for (const handler of this.typingIndicatorHandlers) {
+            try {
+              handler(indicator);
+            } catch (e) {
+              this.log("Typing handler error:", e);
+            }
+          }
+          return;
+        }
+      } catch {
+      }
+      if (!isChatMessage(pm)) {
+        this.log("Skipping unknown message kind:", pm.kind);
         return;
       }
       let content = pm.content;
@@ -2140,7 +2285,9 @@ var NostrTransportProvider = class {
       }
       this.log("DM received from:", senderNametag || pm.senderPubkey?.slice(0, 16), "content:", content?.slice(0, 50));
       const message = {
-        id: pm.eventId,
+        // Use outer gift wrap event.id so it matches the sender's stored giftWrap.id.
+        // This ensures read receipts reference an ID the sender recognizes.
+        id: event.id,
         senderTransportPubkey: pm.senderPubkey,
         senderNametag,
         content,
@@ -5060,6 +5207,363 @@ function createPriceProvider(config) {
   }
 }
 
+// registry/TokenRegistry.ts
+var FETCH_TIMEOUT_MS = 1e4;
+var TokenRegistry = class _TokenRegistry {
+  static instance = null;
+  definitionsById;
+  definitionsBySymbol;
+  definitionsByName;
+  // Remote refresh state
+  remoteUrl = null;
+  storage = null;
+  refreshIntervalMs = TOKEN_REGISTRY_REFRESH_INTERVAL;
+  refreshTimer = null;
+  lastRefreshAt = 0;
+  refreshPromise = null;
+  constructor() {
+    this.definitionsById = /* @__PURE__ */ new Map();
+    this.definitionsBySymbol = /* @__PURE__ */ new Map();
+    this.definitionsByName = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Get singleton instance of TokenRegistry
+   */
+  static getInstance() {
+    if (!_TokenRegistry.instance) {
+      _TokenRegistry.instance = new _TokenRegistry();
+    }
+    return _TokenRegistry.instance;
+  }
+  /**
+   * Configure remote registry refresh with persistent caching.
+   *
+   * On first call:
+   * 1. Loads cached data from StorageProvider (if available and fresh)
+   * 2. Starts periodic remote fetch (if autoRefresh is true, which is default)
+   *
+   * @param options - Configuration options
+   * @param options.remoteUrl - Remote URL to fetch definitions from
+   * @param options.storage - StorageProvider for persistent caching
+   * @param options.refreshIntervalMs - Refresh interval in ms (default: 1 hour)
+   * @param options.autoRefresh - Start auto-refresh immediately (default: true)
+   */
+  static configure(options) {
+    const instance = _TokenRegistry.getInstance();
+    if (options.remoteUrl !== void 0) {
+      instance.remoteUrl = options.remoteUrl;
+    }
+    if (options.storage !== void 0) {
+      instance.storage = options.storage;
+    }
+    if (options.refreshIntervalMs !== void 0) {
+      instance.refreshIntervalMs = options.refreshIntervalMs;
+    }
+    if (instance.storage) {
+      instance.loadFromCache();
+    }
+    const autoRefresh = options.autoRefresh ?? true;
+    if (autoRefresh && instance.remoteUrl) {
+      instance.startAutoRefresh();
+    }
+  }
+  /**
+   * Reset the singleton instance (useful for testing).
+   * Stops auto-refresh if running.
+   */
+  static resetInstance() {
+    if (_TokenRegistry.instance) {
+      _TokenRegistry.instance.stopAutoRefresh();
+    }
+    _TokenRegistry.instance = null;
+  }
+  /**
+   * Destroy the singleton: stop auto-refresh and reset.
+   */
+  static destroy() {
+    _TokenRegistry.resetInstance();
+  }
+  // ===========================================================================
+  // Cache (StorageProvider)
+  // ===========================================================================
+  /**
+   * Load definitions from StorageProvider cache.
+   * Only applies if cache exists and is fresh (within refreshIntervalMs).
+   */
+  async loadFromCache() {
+    if (!this.storage) return false;
+    try {
+      const [cached, cachedTs] = await Promise.all([
+        this.storage.get(STORAGE_KEYS_GLOBAL.TOKEN_REGISTRY_CACHE),
+        this.storage.get(STORAGE_KEYS_GLOBAL.TOKEN_REGISTRY_CACHE_TS)
+      ]);
+      if (!cached || !cachedTs) return false;
+      const ts = parseInt(cachedTs, 10);
+      if (isNaN(ts)) return false;
+      const age = Date.now() - ts;
+      if (age > this.refreshIntervalMs) return false;
+      if (this.lastRefreshAt > ts) return false;
+      const data = JSON.parse(cached);
+      if (!this.isValidDefinitionsArray(data)) return false;
+      this.applyDefinitions(data);
+      this.lastRefreshAt = ts;
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Save definitions to StorageProvider cache.
+   */
+  async saveToCache(definitions) {
+    if (!this.storage) return;
+    try {
+      await Promise.all([
+        this.storage.set(STORAGE_KEYS_GLOBAL.TOKEN_REGISTRY_CACHE, JSON.stringify(definitions)),
+        this.storage.set(STORAGE_KEYS_GLOBAL.TOKEN_REGISTRY_CACHE_TS, String(Date.now()))
+      ]);
+    } catch {
+    }
+  }
+  // ===========================================================================
+  // Remote Refresh
+  // ===========================================================================
+  /**
+   * Apply an array of token definitions to the internal maps.
+   * Clears existing data before applying.
+   */
+  applyDefinitions(definitions) {
+    this.definitionsById.clear();
+    this.definitionsBySymbol.clear();
+    this.definitionsByName.clear();
+    for (const def of definitions) {
+      const idLower = def.id.toLowerCase();
+      this.definitionsById.set(idLower, def);
+      if (def.symbol) {
+        this.definitionsBySymbol.set(def.symbol.toUpperCase(), def);
+      }
+      this.definitionsByName.set(def.name.toLowerCase(), def);
+    }
+  }
+  /**
+   * Validate that data is an array of objects with 'id' field
+   */
+  isValidDefinitionsArray(data) {
+    return Array.isArray(data) && data.every((item) => item && typeof item === "object" && "id" in item);
+  }
+  /**
+   * Fetch token definitions from the remote URL and update the registry.
+   * On success, also persists to StorageProvider cache.
+   * Returns true on success, false on failure. On failure, existing data is preserved.
+   * Concurrent calls are deduplicated — only one fetch runs at a time.
+   */
+  async refreshFromRemote() {
+    if (!this.remoteUrl) {
+      return false;
+    }
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.refreshPromise = this.doRefresh();
+    try {
+      return await this.refreshPromise;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  async doRefresh() {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+      let response;
+      try {
+        response = await fetch(this.remoteUrl, {
+          headers: { Accept: "application/json" },
+          signal: controller.signal
+        });
+      } finally {
+        clearTimeout(timer);
+      }
+      if (!response.ok) {
+        console.warn(
+          `[TokenRegistry] Remote fetch failed: HTTP ${response.status} ${response.statusText}`
+        );
+        return false;
+      }
+      const data = await response.json();
+      if (!this.isValidDefinitionsArray(data)) {
+        console.warn("[TokenRegistry] Remote data is not a valid token definitions array");
+        return false;
+      }
+      const definitions = data;
+      this.applyDefinitions(definitions);
+      this.lastRefreshAt = Date.now();
+      this.saveToCache(definitions);
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(`[TokenRegistry] Remote refresh failed: ${message}`);
+      return false;
+    }
+  }
+  /**
+   * Start periodic auto-refresh from the remote URL.
+   * Does an immediate fetch, then repeats at the configured interval.
+   */
+  startAutoRefresh(intervalMs) {
+    this.stopAutoRefresh();
+    if (intervalMs !== void 0) {
+      this.refreshIntervalMs = intervalMs;
+    }
+    this.refreshFromRemote();
+    this.refreshTimer = setInterval(() => {
+      this.refreshFromRemote();
+    }, this.refreshIntervalMs);
+  }
+  /**
+   * Stop periodic auto-refresh
+   */
+  stopAutoRefresh() {
+    if (this.refreshTimer !== null) {
+      clearInterval(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+  }
+  /**
+   * Timestamp of the last successful remote refresh (0 if never refreshed)
+   */
+  getLastRefreshAt() {
+    return this.lastRefreshAt;
+  }
+  // ===========================================================================
+  // Lookup Methods
+  // ===========================================================================
+  /**
+   * Get token definition by hex coin ID
+   * @param coinId - 64-character hex string
+   * @returns Token definition or undefined if not found
+   */
+  getDefinition(coinId) {
+    if (!coinId) return void 0;
+    return this.definitionsById.get(coinId.toLowerCase());
+  }
+  /**
+   * Get token definition by symbol (e.g., "UCT", "BTC")
+   * @param symbol - Token symbol (case-insensitive)
+   * @returns Token definition or undefined if not found
+   */
+  getDefinitionBySymbol(symbol) {
+    if (!symbol) return void 0;
+    return this.definitionsBySymbol.get(symbol.toUpperCase());
+  }
+  /**
+   * Get token definition by name (e.g., "bitcoin", "ethereum")
+   * @param name - Token name (case-insensitive)
+   * @returns Token definition or undefined if not found
+   */
+  getDefinitionByName(name) {
+    if (!name) return void 0;
+    return this.definitionsByName.get(name.toLowerCase());
+  }
+  /**
+   * Get token symbol for a coin ID
+   * @param coinId - 64-character hex string
+   * @returns Symbol (e.g., "UCT") or truncated ID if not found
+   */
+  getSymbol(coinId) {
+    const def = this.getDefinition(coinId);
+    if (def?.symbol) {
+      return def.symbol;
+    }
+    return coinId.slice(0, 6).toUpperCase();
+  }
+  /**
+   * Get token name for a coin ID
+   * @param coinId - 64-character hex string
+   * @returns Name (e.g., "Bitcoin") or coin ID if not found
+   */
+  getName(coinId) {
+    const def = this.getDefinition(coinId);
+    if (def?.name) {
+      return def.name.charAt(0).toUpperCase() + def.name.slice(1);
+    }
+    return coinId;
+  }
+  /**
+   * Get decimal places for a coin ID
+   * @param coinId - 64-character hex string
+   * @returns Decimals or 0 if not found
+   */
+  getDecimals(coinId) {
+    const def = this.getDefinition(coinId);
+    return def?.decimals ?? 0;
+  }
+  /**
+   * Get icon URL for a coin ID
+   * @param coinId - 64-character hex string
+   * @param preferPng - Prefer PNG format over SVG
+   * @returns Icon URL or null if not found
+   */
+  getIconUrl(coinId, preferPng = true) {
+    const def = this.getDefinition(coinId);
+    if (!def?.icons || def.icons.length === 0) {
+      return null;
+    }
+    if (preferPng) {
+      const pngIcon = def.icons.find((i) => i.url.toLowerCase().includes(".png"));
+      if (pngIcon) return pngIcon.url;
+    }
+    return def.icons[0].url;
+  }
+  /**
+   * Check if a coin ID is known in the registry
+   * @param coinId - 64-character hex string
+   * @returns true if the coin is in the registry
+   */
+  isKnown(coinId) {
+    return this.definitionsById.has(coinId.toLowerCase());
+  }
+  /**
+   * Get all token definitions
+   * @returns Array of all token definitions
+   */
+  getAllDefinitions() {
+    return Array.from(this.definitionsById.values());
+  }
+  /**
+   * Get all fungible token definitions
+   * @returns Array of fungible token definitions
+   */
+  getFungibleTokens() {
+    return this.getAllDefinitions().filter((def) => def.assetKind === "fungible");
+  }
+  /**
+   * Get all non-fungible token definitions
+   * @returns Array of non-fungible token definitions
+   */
+  getNonFungibleTokens() {
+    return this.getAllDefinitions().filter((def) => def.assetKind === "non-fungible");
+  }
+  /**
+   * Get coin ID by symbol
+   * @param symbol - Token symbol (e.g., "UCT")
+   * @returns Coin ID hex string or undefined if not found
+   */
+  getCoinIdBySymbol(symbol) {
+    const def = this.getDefinitionBySymbol(symbol);
+    return def?.id;
+  }
+  /**
+   * Get coin ID by name
+   * @param name - Token name (e.g., "bitcoin")
+   * @returns Coin ID hex string or undefined if not found
+   */
+  getCoinIdByName(name) {
+    const def = this.getDefinitionByName(name);
+    return def?.id;
+  }
+};
+
 // impl/shared/resolvers.ts
 function getNetworkConfig(network = "mainnet") {
   return NETWORKS[network];
@@ -5145,6 +5649,16 @@ function resolveGroupChatConfig(network, config) {
     relays: config.relays ?? [...netConfig.groupRelays]
   };
 }
+function resolveMarketConfig(config) {
+  if (!config) return void 0;
+  if (config === true) {
+    return { apiUrl: DEFAULT_MARKET_API_URL };
+  }
+  return {
+    apiUrl: config.apiUrl ?? DEFAULT_MARKET_API_URL,
+    timeout: config.timeout
+  };
+}
 
 // impl/browser/index.ts
 if (typeof globalThis.Buffer === "undefined") {
@@ -5211,9 +5725,13 @@ function createBrowserProviders(config) {
     // reuse debug-like flag
   }) : void 0;
   const groupChat = resolveGroupChatConfig(network, config?.groupChat);
+  const networkConfig = getNetworkConfig(network);
+  TokenRegistry.configure({ remoteUrl: networkConfig.tokenRegistryUrl, storage });
+  const market = resolveMarketConfig(config?.market);
   return {
     storage,
     groupChat,
+    market,
     transport: createNostrTransportProvider({
       relays: transportConfig.relays,
       timeout: transportConfig.timeout,