@unicitylabs/sphere-sdk 0.3.5 → 0.3.7

package/dist/impl/nodejs/index.cjs

@@ -86,7 +86,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 */
@@ -162,6 +166,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"
 ];
@@ -175,7 +181,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",
@@ -183,7 +190,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",
@@ -191,7 +199,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 = {
@@ -206,6 +215,7 @@ var TIMEOUTS = {
   /** Sync interval */
   SYNC_INTERVAL: 6e4
 };
+var DEFAULT_MARKET_API_URL = "https://market-api.unicity.network";
 
 // impl/nodejs/storage/FileStorageProvider.ts
 var FileStorageProvider = class {
@@ -1186,6 +1196,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) {
@@ -1437,6 +1449,18 @@ var NostrTransportProvider = class {
     const wrappedContent = senderNametag ? JSON.stringify({ senderNametag, text: content }) : content;
     const giftWrap = import_nostr_js_sdk.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 = import_nostr_js_sdk.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(),
@@ -1535,6 +1559,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 = import_nostr_js_sdk.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 = import_nostr_js_sdk.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.
@@ -1988,11 +2043,74 @@ var NostrTransportProvider = class {
       const pm = import_nostr_js_sdk.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 ((0, import_nostr_js_sdk.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;
       }
-      if (pm.kind !== import_nostr_js_sdk.EventKinds.CHAT_MESSAGE) {
-        this.log("Skipping non-chat message, kind:", pm.kind);
+      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 (!(0, import_nostr_js_sdk.isChatMessage)(pm)) {
+        this.log("Skipping unknown message kind:", pm.kind);
         return;
       }
       let content = pm.content;
@@ -2007,7 +2125,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,
@@ -4871,6 +4991,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];
@@ -4946,6 +5423,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/nodejs/index.ts
 function createNodeProviders(config) {
@@ -4961,9 +5448,13 @@ function createNodeProviders(config) {
   const ipfsSync = config?.tokenSync?.ipfs;
   const ipfsTokenStorage = ipfsSync?.enabled ? createNodeIpfsStorageProvider(ipfsSync.config, storage) : 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,
     tokenStorage: createFileTokenStorageProvider({
       tokensDir: config?.tokensDir ?? "./sphere-tokens"
     }),