@unicitylabs/sphere-sdk 0.3.7 → 0.3.8

package/dist/impl/browser/index.js

@@ -40,7 +40,11 @@ var STORAGE_KEYS_GLOBAL = {
   /** 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"
+  TOKEN_REGISTRY_CACHE_TS: "token_registry_cache_ts",
+  /** Cached price data JSON (from CoinGecko or other provider) */
+  PRICE_CACHE: "price_cache",
+  /** Timestamp of last price cache update (ms since epoch) */
+  PRICE_CACHE_TS: "price_cache_ts"
 };
 var STORAGE_KEYS_ADDRESS = {
   /** Pending transfers for this address */
@@ -165,7 +169,6 @@ 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 {
@@ -533,61 +536,36 @@ var IndexedDBTokenStorageProvider = class {
     return meta !== null;
   }
   async clear() {
-    const dbNames = [this.dbName];
+    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();
+    });
     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") {
-        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 {
-        }
+        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);
       }
       return true;
     } catch (err) {
@@ -1136,9 +1114,7 @@ import {
   EventKinds,
   hashNametag,
   NostrClient,
-  Filter,
-  isChatMessage,
-  isReadReceipt
+  Filter
 } from "@unicitylabs/nostr-js-sdk";
 
 // core/crypto.ts
@@ -1356,8 +1332,6 @@ 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) {
@@ -1609,18 +1583,6 @@ 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(),
@@ -1719,37 +1681,6 @@ 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.
@@ -2203,74 +2134,11 @@ 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()) {
-        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");
+        this.log("Skipping own message");
         return;
       }
-      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);
+      if (pm.kind !== EventKinds.CHAT_MESSAGE) {
+        this.log("Skipping non-chat message, kind:", pm.kind);
         return;
       }
       let content = pm.content;
@@ -2285,9 +2153,7 @@ var NostrTransportProvider = class {
       }
       this.log("DM received from:", senderNametag || pm.senderPubkey?.slice(0, 16), "content:", content?.slice(0, 50));
       const message = {
-        // 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,
+        id: pm.eventId,
         senderTransportPubkey: pm.senderPubkey,
         senderNametag,
         content,
@@ -3365,6 +3231,7 @@ async function loadIpnsModule() {
 async function createSignedRecord(keyPair, cid, sequenceNumber, lifetimeMs = DEFAULT_LIFETIME_MS) {
   const { createIPNSRecord, marshalIPNSRecord } = await loadIpnsModule();
   const record = await createIPNSRecord(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     keyPair,
     `/ipfs/${cid}`,
     sequenceNumber,
@@ -5109,26 +4976,37 @@ var CoinGeckoPriceProvider = class {
   timeout;
   debug;
   baseUrl;
+  storage;
+  /** In-flight fetch promise for deduplication of concurrent getPrices() calls */
+  fetchPromise = null;
+  /** Token names being fetched in the current in-flight request */
+  fetchNames = null;
+  /** Whether persistent cache has been loaded into memory */
+  persistentCacheLoaded = false;
+  /** Promise for loading persistent cache (deduplication) */
+  loadCachePromise = null;
   constructor(config) {
     this.apiKey = config?.apiKey;
     this.cacheTtlMs = config?.cacheTtlMs ?? 6e4;
     this.timeout = config?.timeout ?? 1e4;
     this.debug = config?.debug ?? false;
+    this.storage = config?.storage ?? null;
     this.baseUrl = config?.baseUrl ?? (this.apiKey ? "https://pro-api.coingecko.com/api/v3" : "https://api.coingecko.com/api/v3");
   }
   async getPrices(tokenNames) {
     if (tokenNames.length === 0) {
       return /* @__PURE__ */ new Map();
     }
+    if (!this.persistentCacheLoaded && this.storage) {
+      await this.loadFromStorage();
+    }
     const now = Date.now();
     const result = /* @__PURE__ */ new Map();
     const uncachedNames = [];
     for (const name of tokenNames) {
       const cached = this.cache.get(name);
       if (cached && cached.expiresAt > now) {
-        if (cached.price !== null) {
-          result.set(name, cached.price);
-        }
+        result.set(name, cached.price);
       } else {
         uncachedNames.push(name);
       }
@@ -5136,6 +5014,41 @@ var CoinGeckoPriceProvider = class {
     if (uncachedNames.length === 0) {
       return result;
     }
+    if (this.fetchPromise && this.fetchNames) {
+      const allCovered = uncachedNames.every((n) => this.fetchNames.has(n));
+      if (allCovered) {
+        if (this.debug) {
+          console.log(`[CoinGecko] Deduplicating request, reusing in-flight fetch`);
+        }
+        const fetched = await this.fetchPromise;
+        for (const name of uncachedNames) {
+          const price = fetched.get(name);
+          if (price) {
+            result.set(name, price);
+          }
+        }
+        return result;
+      }
+    }
+    const fetchPromise = this.doFetch(uncachedNames);
+    this.fetchPromise = fetchPromise;
+    this.fetchNames = new Set(uncachedNames);
+    try {
+      const fetched = await fetchPromise;
+      for (const [name, price] of fetched) {
+        result.set(name, price);
+      }
+    } finally {
+      if (this.fetchPromise === fetchPromise) {
+        this.fetchPromise = null;
+        this.fetchNames = null;
+      }
+    }
+    return result;
+  }
+  async doFetch(uncachedNames) {
+    const result = /* @__PURE__ */ new Map();
+    const now = Date.now();
     try {
       const ids = uncachedNames.join(",");
       const url = `${this.baseUrl}/simple/price?ids=${encodeURIComponent(ids)}&vs_currencies=usd,eur&include_24hr_change=true`;
@@ -5151,6 +5064,9 @@ var CoinGeckoPriceProvider = class {
         signal: AbortSignal.timeout(this.timeout)
       });
       if (!response.ok) {
+        if (response.status === 429) {
+          this.extendCacheOnRateLimit(uncachedNames);
+        }
         throw new Error(`CoinGecko API error: ${response.status} ${response.statusText}`);
       }
       const data = await response.json();
@@ -5169,25 +5085,113 @@ var CoinGeckoPriceProvider = class {
       }
       for (const name of uncachedNames) {
         if (!result.has(name)) {
-          this.cache.set(name, { price: null, expiresAt: now + this.cacheTtlMs });
+          const zeroPrice = {
+            tokenName: name,
+            priceUsd: 0,
+            priceEur: 0,
+            change24h: 0,
+            timestamp: now
+          };
+          this.cache.set(name, { price: zeroPrice, expiresAt: now + this.cacheTtlMs });
+          result.set(name, zeroPrice);
         }
       }
       if (this.debug) {
         console.log(`[CoinGecko] Fetched ${result.size} prices`);
       }
+      this.saveToStorage();
     } catch (error) {
       if (this.debug) {
         console.warn("[CoinGecko] Fetch failed, using stale cache:", error);
       }
       for (const name of uncachedNames) {
         const stale = this.cache.get(name);
-        if (stale?.price) {
+        if (stale) {
           result.set(name, stale.price);
         }
       }
     }
     return result;
   }
+  // ===========================================================================
+  // Persistent Storage
+  // ===========================================================================
+  /**
+   * Load cached prices from StorageProvider into in-memory cache.
+   * Only loads entries that are still within cacheTtlMs.
+   */
+  async loadFromStorage() {
+    if (this.loadCachePromise) {
+      return this.loadCachePromise;
+    }
+    this.loadCachePromise = this.doLoadFromStorage();
+    try {
+      await this.loadCachePromise;
+    } finally {
+      this.loadCachePromise = null;
+    }
+  }
+  async doLoadFromStorage() {
+    this.persistentCacheLoaded = true;
+    if (!this.storage) return;
+    try {
+      const [cached, cachedTs] = await Promise.all([
+        this.storage.get(STORAGE_KEYS_GLOBAL.PRICE_CACHE),
+        this.storage.get(STORAGE_KEYS_GLOBAL.PRICE_CACHE_TS)
+      ]);
+      if (!cached || !cachedTs) return;
+      const ts = parseInt(cachedTs, 10);
+      if (isNaN(ts)) return;
+      const age = Date.now() - ts;
+      if (age > this.cacheTtlMs) return;
+      const data = JSON.parse(cached);
+      const expiresAt = ts + this.cacheTtlMs;
+      for (const [name, price] of Object.entries(data)) {
+        if (!this.cache.has(name)) {
+          this.cache.set(name, { price, expiresAt });
+        }
+      }
+      if (this.debug) {
+        console.log(`[CoinGecko] Loaded ${Object.keys(data).length} prices from persistent cache`);
+      }
+    } catch {
+    }
+  }
+  /**
+   * Save current prices to StorageProvider (fire-and-forget).
+   */
+  saveToStorage() {
+    if (!this.storage) return;
+    const data = {};
+    for (const [name, entry] of this.cache) {
+      data[name] = entry.price;
+    }
+    Promise.all([
+      this.storage.set(STORAGE_KEYS_GLOBAL.PRICE_CACHE, JSON.stringify(data)),
+      this.storage.set(STORAGE_KEYS_GLOBAL.PRICE_CACHE_TS, String(Date.now()))
+    ]).catch(() => {
+    });
+  }
+  // ===========================================================================
+  // Rate-limit handling
+  // ===========================================================================
+  /**
+   * On 429 rate-limit, extend stale cache entries so subsequent calls
+   * don't immediately retry and hammer the API.
+   */
+  extendCacheOnRateLimit(names) {
+    const backoffMs = 6e4;
+    const extendedExpiry = Date.now() + backoffMs;
+    for (const name of names) {
+      const existing = this.cache.get(name);
+      if (existing) {
+        existing.expiresAt = Math.max(existing.expiresAt, extendedExpiry);
+      }
+    }
+    if (this.debug) {
+      console.warn(`[CoinGecko] Rate-limited (429), extended cache TTL by ${backoffMs / 1e3}s`);
+    }
+  }
   async getPrice(tokenName) {
     const prices = await this.getPrices([tokenName]);
     return prices.get(tokenName) ?? null;
@@ -5221,6 +5225,7 @@ var TokenRegistry = class _TokenRegistry {
   refreshTimer = null;
   lastRefreshAt = 0;
   refreshPromise = null;
+  initialLoadPromise = null;
   constructor() {
     this.definitionsById = /* @__PURE__ */ new Map();
     this.definitionsBySymbol = /* @__PURE__ */ new Map();
@@ -5259,13 +5264,8 @@ var TokenRegistry = class _TokenRegistry {
     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();
-    }
+    instance.initialLoadPromise = instance.performInitialLoad(autoRefresh);
   }
   /**
    * Reset the singleton instance (useful for testing).
@@ -5283,6 +5283,53 @@ var TokenRegistry = class _TokenRegistry {
   static destroy() {
     _TokenRegistry.resetInstance();
   }
+  /**
+   * Wait for the initial data load (cache or remote) to complete.
+   * Returns true if data was loaded, false if not (timeout or no data source).
+   *
+   * @param timeoutMs - Maximum wait time in ms (default: 10s). Set to 0 for no timeout.
+   */
+  static async waitForReady(timeoutMs = 1e4) {
+    const instance = _TokenRegistry.getInstance();
+    if (!instance.initialLoadPromise) {
+      return instance.definitionsById.size > 0;
+    }
+    if (timeoutMs <= 0) {
+      return instance.initialLoadPromise;
+    }
+    return Promise.race([
+      instance.initialLoadPromise,
+      new Promise((resolve) => setTimeout(() => resolve(false), timeoutMs))
+    ]);
+  }
+  // ===========================================================================
+  // Initial Load
+  // ===========================================================================
+  /**
+   * Perform initial data load: try cache first, fall back to remote fetch.
+   * After initial data is available, start periodic auto-refresh if configured.
+   */
+  async performInitialLoad(autoRefresh) {
+    let loaded = false;
+    if (this.storage) {
+      loaded = await this.loadFromCache();
+    }
+    if (loaded) {
+      if (autoRefresh && this.remoteUrl) {
+        this.startAutoRefresh();
+      }
+      return true;
+    }
+    if (autoRefresh && this.remoteUrl) {
+      loaded = await this.refreshFromRemote();
+      this.stopAutoRefresh();
+      this.refreshTimer = setInterval(() => {
+        this.refreshFromRemote();
+      }, this.refreshIntervalMs);
+      return loaded;
+    }
+    return false;
+  }
   // ===========================================================================
   // Cache (StorageProvider)
   // ===========================================================================
@@ -5612,7 +5659,7 @@ function resolveL1Config(network, config) {
     enableVesting: config.enableVesting
   };
 }
-function resolvePriceConfig(config) {
+function resolvePriceConfig(config, storage) {
   if (config === void 0) {
     return void 0;
   }
@@ -5622,7 +5669,8 @@ function resolvePriceConfig(config) {
     baseUrl: config.baseUrl,
     cacheTtlMs: config.cacheTtlMs,
     timeout: config.timeout,
-    debug: config.debug
+    debug: config.debug,
+    storage
   };
 }
 function resolveArrayConfig(defaults, replace, additional) {
@@ -5649,16 +5697,6 @@ 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") {
@@ -5716,8 +5754,8 @@ function createBrowserProviders(config) {
   const oracleConfig = resolveOracleConfig(network, config?.oracle);
   const l1Config = resolveL1Config(network, config?.l1);
   const tokenSyncConfig = resolveTokenSyncConfig(network, config?.tokenSync);
-  const priceConfig = resolvePriceConfig(config?.price);
   const storage = createLocalStorageProvider(config?.storage);
+  const priceConfig = resolvePriceConfig(config?.price, storage);
   const ipfsConfig = tokenSyncConfig?.ipfs;
   const ipfsTokenStorage = ipfsConfig?.enabled ? createBrowserIpfsStorageProvider({
     gateways: ipfsConfig.gateways,
@@ -5727,11 +5765,9 @@ function createBrowserProviders(config) {
   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,