@routstr/sdk 0.3.8 → 0.3.9

package/dist/index.js

@@ -139,6 +139,9 @@ var MintDiscoveryError = class extends Error {
   }
   baseUrl;
 };
+function isBunRuntime() {
+  return typeof Bun !== "undefined";
+}
 var ModelManager = class _ModelManager {
   constructor(adapter, config = {}) {
     this.adapter = adapter;
@@ -148,6 +151,7 @@ var ModelManager = class _ModelManager {
     this.excludeProviderUrls = config.excludeProviderUrls || [];
     this.routstrPubkey = config.routstrPubkey || "4ad6fa2d16e2a9b576c863b4cf7404a70d4dc320c0c447d10ad6ff58993eacc8";
     this.logger = (config.logger ?? consoleLogger).child("ModelManager");
+    this.eventStoreDbPath = config.eventStoreDbPath;
   }
   adapter;
   cacheTTL;
@@ -157,6 +161,11 @@ var ModelManager = class _ModelManager {
   routstrPubkey;
   logger;
   providerNodePubkeysByUrl = /* @__PURE__ */ new Map();
+  /** Persistent event store for relay-fetched events (null if not configured/initialized) */
+  eventStore = null;
+  eventStoreDb = null;
+  eventStoreInitPromise = null;
+  eventStoreDbPath;
   /**
    * Get the list of bootstrapped provider base URLs
    * @returns Array of provider base URLs
@@ -164,6 +173,104 @@ var ModelManager = class _ModelManager {
   getBaseUrls() {
     return this.adapter.getBaseUrlsList();
   }
+  /**
+   * Lazily initialize the persistent event store.
+   * Returns null if no eventStoreDbPath was provided.
+   */
+  async ensureEventStore() {
+    if (!this.eventStoreDbPath) return null;
+    if (this.eventStore) return this.eventStore;
+    if (!this.eventStoreInitPromise) {
+      this.eventStoreInitPromise = (async () => {
+        try {
+          const db = await this.createPersistentEventDatabase();
+          this.eventStoreDb = db;
+          this.eventStore = new applesauceCore.EventStore({ database: db });
+          this.initializeEventStoreMetadata();
+          this.logger.log(
+            `Persistent event store initialized at ${this.eventStoreDbPath}`
+          );
+          return this.eventStore;
+        } catch (error) {
+          this.eventStoreInitPromise = null;
+          throw new Error(
+            `applesauce-sqlite with a supported SQLite driver is required for persistent Nostr event storage. Bun uses bun:sqlite; Node.js uses better-sqlite3. Install optional dependencies or omit eventStoreDbPath. (${error})`
+          );
+        }
+      })();
+    }
+    return this.eventStoreInitPromise;
+  }
+  /**
+   * Get the persistent event store, initializing it if configured.
+   * Returns null if no eventStoreDbPath was provided.
+   */
+  async getEventStore() {
+    return this.ensureEventStore();
+  }
+  async createPersistentEventDatabase() {
+    if (isBunRuntime()) {
+      const { BunSqliteEventDatabase } = await import('applesauce-sqlite/bun');
+      return new BunSqliteEventDatabase(
+        this.eventStoreDbPath
+      );
+    }
+    const { BetterSqlite3EventDatabase } = await import('applesauce-sqlite/better-sqlite3');
+    return new BetterSqlite3EventDatabase(
+      this.eventStoreDbPath
+    );
+  }
+  /** Close the persistent event store database handle, if configured. */
+  closeEventStore() {
+    this.eventStoreDb?.close?.();
+    this.eventStore = null;
+    this.eventStoreDb = null;
+    this.eventStoreInitPromise = null;
+  }
+  initializeEventStoreMetadata() {
+    this.eventStoreDb?.db?.exec(
+      `CREATE TABLE IF NOT EXISTS routstr_event_cache_metadata (
+        event_id TEXT PRIMARY KEY,
+        fetched_at INTEGER NOT NULL
+      )`
+    );
+  }
+  markEventFetched(event, fetchedAt = Date.now()) {
+    const db = this.eventStoreDb?.db;
+    if (!db) return;
+    db.prepare(
+      `INSERT INTO routstr_event_cache_metadata (event_id, fetched_at)
+       VALUES (?, ?)
+       ON CONFLICT(event_id) DO UPDATE SET fetched_at = excluded.fetched_at`
+    ).run?.(event.id, fetchedAt);
+  }
+  getEventFetchedAt(event) {
+    const db = this.eventStoreDb?.db;
+    if (!db) return void 0;
+    const row = db.prepare(
+      `SELECT fetched_at FROM routstr_event_cache_metadata WHERE event_id = ?`
+    ).get?.(event.id);
+    return typeof row?.fetched_at === "number" ? row.fetched_at : void 0;
+  }
+  /**
+   * Check the persistent event store for fresh cached events.
+   * Returns events from SQLite if they were fetched within `maxAge`, otherwise
+   * returns empty array (caller should hit relays). Events without local fetch
+   * metadata fall back to Nostr created_at for backwards compatibility.
+   */
+  async getCachedNostrEvents(filter, maxAge, forceRefresh = false) {
+    const eventStore = await this.ensureEventStore();
+    if (forceRefresh) return [];
+    if (!eventStore) return [];
+    const timeline = eventStore.getTimeline(filter);
+    if (timeline.length === 0) return [];
+    const cutoff = Date.now() - maxAge;
+    const freshest = Math.max(
+      ...timeline.map((e) => this.getEventFetchedAt(e) ?? e.created_at * 1e3)
+    );
+    if (freshest < cutoff) return [];
+    return timeline;
+  }
   static async init(adapter, config = {}, options = {}) {
     const manager = new _ModelManager(adapter, config);
     const torMode = options.torMode ?? false;
@@ -192,19 +299,31 @@ var ModelManager = class _ModelManager {
             torMode
           );
           await this.fetchRoutstr21Models(forceRefresh);
-          await this.syncReviewedProvidersFromNostr(filteredCachedUrls);
+          await this.syncReviewedProvidersFromNostr(
+            filteredCachedUrls,
+            this.providerNodePubkeysByUrl,
+            forceRefresh
+          );
           return filteredCachedUrls;
         }
       }
     }
     try {
-      const nostrProviders = await this.bootstrapFromNostr(38421, torMode);
+      const nostrProviders = await this.bootstrapFromNostr(
+        38421,
+        torMode,
+        forceRefresh
+      );
       if (nostrProviders.length > 0) {
         const filtered = this.filterBaseUrlsForTor(nostrProviders, torMode);
         this.adapter.setBaseUrlsList(filtered);
         this.adapter.setBaseUrlsLastUpdate(Date.now());
         await this.fetchRoutstr21Models(forceRefresh);
-        await this.syncReviewedProvidersFromNostr(filtered);
+        await this.syncReviewedProvidersFromNostr(
+          filtered,
+          this.providerNodePubkeysByUrl,
+          forceRefresh
+        );
         return filtered;
       }
     } catch (e) {
@@ -213,42 +332,52 @@ var ModelManager = class _ModelManager {
     return this.bootstrapFromHttp(torMode, forceRefresh);
   }
   /**
-   * Bootstrap providers from Nostr network (kind 30421)
+   * Bootstrap providers from Nostr network (kind 38421)
    * @param kind The Nostr kind to fetch
    * @param torMode Whether running in Tor context
    * @returns Array of provider base URLs
    */
-  async bootstrapFromNostr(kind, torMode) {
+  async bootstrapFromNostr(kind, torMode, forceRefresh = false) {
     const DEFAULT_RELAYS = [
       "wss://relay.primal.net",
       "wss://nos.lol",
       "wss://relay.damus.io"
     ];
-    const pool = new applesauceRelay.RelayPool();
-    const localEventStore = new applesauceCore.EventStore();
-    const timeoutMs = 5e3;
-    await new Promise((resolve) => {
-      pool.req(DEFAULT_RELAYS, {
-        kinds: [kind],
-        limit: 100
-      }).pipe(
-        applesauceRelay.onlyEvents(),
-        rxjs.tap((event) => {
-          localEventStore.add(event);
-        })
-      ).subscribe({
-        complete: () => {
+    const cached = await this.getCachedNostrEvents(
+      { kinds: [kind] },
+      this.cacheTTL,
+      forceRefresh
+    );
+    let sessionEvents = cached;
+    if (cached.length === 0) {
+      const pool = new applesauceRelay.RelayPool();
+      const timeoutMs = 5e3;
+      await new Promise((resolve) => {
+        pool.req(DEFAULT_RELAYS, {
+          kinds: [kind],
+          limit: 100
+        }).pipe(
+          applesauceRelay.onlyEvents(),
+          rxjs.tap((event) => {
+            sessionEvents.push(event);
+            this.eventStore?.add(event);
+            this.markEventFetched(event);
+          })
+        ).subscribe({
+          complete: () => {
+            resolve();
+          }
+        });
+        setTimeout(() => {
           resolve();
-        }
+        }, timeoutMs);
       });
-      setTimeout(() => {
-        resolve();
-      }, timeoutMs);
-    });
-    const timeline = localEventStore.getTimeline({ kinds: [kind] });
+    } else {
+      this.logger.log(`Using ${cached.length} cached kind ${kind} events from persistent store`);
+    }
     const bases = /* @__PURE__ */ new Set();
     this.providerNodePubkeysByUrl = /* @__PURE__ */ new Map();
-    for (const event of timeline) {
+    for (const event of sessionEvents) {
       const eventUrls = [];
       for (const tag of event.tags) {
         if (tag[0] === "u" && typeof tag[1] === "string") {
@@ -356,7 +485,11 @@ var ModelManager = class _ModelManager {
         this.adapter.setBaseUrlsList(list);
         this.adapter.setBaseUrlsLastUpdate(Date.now());
         await this.fetchRoutstr21Models(forceRefresh);
-        await this.syncReviewedProvidersFromNostr(list);
+        await this.syncReviewedProvidersFromNostr(
+          list,
+          this.providerNodePubkeysByUrl,
+          forceRefresh
+        );
       }
       return list;
     } catch (e) {
@@ -375,7 +508,7 @@ var ModelManager = class _ModelManager {
    * @param baseUrls Current provider base URLs to evaluate
    * @returns Array of provider base URLs disabled by the review set
    */
-  async syncReviewedProvidersFromNostr(baseUrls = this.adapter.getBaseUrlsList(), providerNodes = this.providerNodePubkeysByUrl) {
+  async syncReviewedProvidersFromNostr(baseUrls = this.adapter.getBaseUrlsList(), providerNodes = this.providerNodePubkeysByUrl, forceRefresh = false) {
     if (baseUrls.length === 0) return [];
     if (!this.adapter.setDisabledProviders) {
       this.logger.warn(
@@ -383,30 +516,43 @@ var ModelManager = class _ModelManager {
       );
       return [];
     }
-    const LGTM_RELAYS = [
-      "wss://relay.primal.net",
-      "wss://nos.lol",
-      "wss://relay.damus.io",
-      "wss://relay.routstr.com"
-    ];
     const reviewedNodePubkeys = /* @__PURE__ */ new Set();
     {
-      const pool = new applesauceRelay.RelayPool();
-      const store = new applesauceCore.EventStore();
-      const timeoutMs = 5e3;
-      await new Promise((resolve) => {
-        pool.req(LGTM_RELAYS, {
-          kinds: [38425],
-          "#t": ["lgtm"],
-          limit: 500,
-          authors: [this.routstrPubkey]
-        }).pipe(
-          applesauceRelay.onlyEvents(),
-          rxjs.tap((event) => store.add(event))
-        ).subscribe({ complete: () => resolve() });
-        setTimeout(() => resolve(), timeoutMs);
-      });
-      for (const event of store.getTimeline({ kinds: [38425] })) {
+      const cached = await this.getCachedNostrEvents(
+        { kinds: [38425], "#t": ["lgtm"], authors: [this.routstrPubkey] },
+        this.cacheTTL,
+        forceRefresh
+      );
+      let sessionEvents = cached;
+      if (cached.length === 0) {
+        const LGTM_RELAYS = [
+          "wss://relay.primal.net",
+          "wss://nos.lol",
+          "wss://relay.damus.io",
+          "wss://relay.routstr.com"
+        ];
+        const pool = new applesauceRelay.RelayPool();
+        const timeoutMs = 5e3;
+        await new Promise((resolve) => {
+          pool.req(LGTM_RELAYS, {
+            kinds: [38425],
+            "#t": ["lgtm"],
+            limit: 500,
+            authors: [this.routstrPubkey]
+          }).pipe(
+            applesauceRelay.onlyEvents(),
+            rxjs.tap((event) => {
+              sessionEvents.push(event);
+              this.eventStore?.add(event);
+              this.markEventFetched(event);
+            })
+          ).subscribe({ complete: () => resolve() });
+          setTimeout(() => resolve(), timeoutMs);
+        });
+      } else {
+        this.logger.log(`Using ${cached.length} cached kind 38425 events from persistent store`);
+      }
+      for (const event of sessionEvents) {
         const hasLgtmTag = event.tags.some(
           (tag) => tag[0] === "t" && tag[1]?.toLowerCase() === "lgtm"
         );
@@ -515,7 +661,7 @@ var ModelManager = class _ModelManager {
         if (this.isProviderDownError(error)) {
           this.logger.warn(`Provider ${base} is down right now.`);
         } else {
-          this.logger.warn(`Failed to fetch models from ${base}:`, error);
+          this.logger.warn(`Provider ${base} unreachable: ${error.message}`);
         }
         this.adapter.setProviderLastUpdate(base, Date.now());
         return { success: false, base };
@@ -635,34 +781,44 @@ var ModelManager = class _ModelManager {
       "wss://nos.lol",
       "wss://relay.routstr.com"
     ];
-    const pool = new applesauceRelay.RelayPool();
-    const localEventStore = new applesauceCore.EventStore();
-    const timeoutMs = 5e3;
-    await new Promise((resolve) => {
-      pool.req(DEFAULT_RELAYS, {
-        kinds: [38423],
-        "#d": ["routstr-21-models"],
-        limit: 1,
-        authors: [this.routstrPubkey]
-      }).pipe(
-        applesauceRelay.onlyEvents(),
-        rxjs.tap((event2) => {
-          localEventStore.add(event2);
-        })
-      ).subscribe({
-        complete: () => {
+    const cached = await this.getCachedNostrEvents(
+      { kinds: [38423], "#d": ["routstr-21-models"], authors: [this.routstrPubkey] },
+      this.cacheTTL,
+      forceRefresh
+    );
+    let sessionEvents = cached;
+    if (cached.length === 0) {
+      const pool = new applesauceRelay.RelayPool();
+      const timeoutMs = 5e3;
+      await new Promise((resolve) => {
+        pool.req(DEFAULT_RELAYS, {
+          kinds: [38423],
+          "#d": ["routstr-21-models"],
+          limit: 1,
+          authors: [this.routstrPubkey]
+        }).pipe(
+          applesauceRelay.onlyEvents(),
+          rxjs.tap((event2) => {
+            sessionEvents.push(event2);
+            this.eventStore?.add(event2);
+            this.markEventFetched(event2);
+          })
+        ).subscribe({
+          complete: () => {
+            resolve();
+          }
+        });
+        setTimeout(() => {
           resolve();
-        }
+        }, timeoutMs);
       });
-      setTimeout(() => {
-        resolve();
-      }, timeoutMs);
-    });
-    const timeline = localEventStore.getTimeline({ kinds: [38423] });
-    if (timeline.length === 0) {
+    } else {
+      this.logger.log(`Using ${cached.length} cached kind 38423 events from persistent store`);
+    }
+    if (sessionEvents.length === 0) {
       return cachedModels.length > 0 ? cachedModels : [];
     }
-    const event = timeline[0];
+    const event = sessionEvents[0];
     try {
       const content = JSON.parse(event.content);
       const models = Array.isArray(content?.models) ? content.models : [];
@@ -1380,7 +1536,7 @@ var CashuSpender = class {
             });
             continue;
           }
-          if (balanceResult.amount >= 0) {
+          if (balanceResult.amount >= 0 && !balanceResult.balanceUnknown) {
             const balanceSat = balanceResult.unit === "msat" ? Math.floor(balanceResult.amount / 1e3) : balanceResult.amount;
             this.storageAdapter.updateApiKeyBalance(
               apiKeyEntry.baseUrl,
@@ -2129,17 +2285,24 @@ var BalanceManager = class _BalanceManager {
         this.logger.warn("getTokenBalance: FAILED", data);
         const isInvalidApiKey = response.status === 401 && data?.detail?.error?.code === "invalid_api_key" && data?.detail?.error?.message?.includes("proofs already spent");
         return {
-          amount: -1,
+          amount: 0,
           reserved: data.reserved ?? 0,
           unit: "msat",
           apiKey: data.api_key,
-          isInvalidApiKey
+          isInvalidApiKey,
+          balanceUnknown: true
         };
       }
     } catch (error) {
       this.logger.error("getTokenBalance error", error);
     }
-    return { amount: -1, reserved: 0, unit: "sat", apiKey: "" };
+    return {
+      amount: 0,
+      reserved: 0,
+      unit: "sat",
+      apiKey: "",
+      balanceUnknown: true
+    };
   }
   /**
    * Handle topup errors with specific error types
@@ -4686,6 +4849,277 @@ var createProviderRegistryFromStore = (store, logger) => {
   };
 };
 
+// storage/shardedDiscoveryAdapter.ts
+var MODEL_KEY_PREFIX = "models:provider:";
+var MODEL_TS_KEY_PREFIX = "models:provider_timestamp:";
+var PROVIDER_INDEX_KEY = "models:provider_index";
+var MIGRATION_MARKER_KEY4 = "models_sharded_migration_v1";
+var encodeBaseUrl = (baseUrl) => encodeURIComponent(baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
+var modelKey = (baseUrl) => `${MODEL_KEY_PREFIX}${encodeBaseUrl(baseUrl)}`;
+var modelTsKey = (baseUrl) => `${MODEL_TS_KEY_PREFIX}${encodeBaseUrl(baseUrl)}`;
+var normalizeBaseUrl6 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var createShardedDiscoveryAdapter = async (options) => {
+  const { driver } = options;
+  const legacyModels = await driver.getItem(SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS, {});
+  const legacyTimestamps = await driver.getItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE, {});
+  if (Object.keys(legacyModels).length > 0) {
+    const migratedProviders = [];
+    for (const [baseUrl, models] of Object.entries(legacyModels)) {
+      const normalized = normalizeBaseUrl6(baseUrl);
+      await driver.setItem(modelKey(normalized), models);
+      const ts = legacyTimestamps[normalized] ?? Date.now();
+      await driver.setItem(modelTsKey(normalized), ts);
+      migratedProviders.push(normalized);
+    }
+    const existingIndex = await driver.getItem(
+      PROVIDER_INDEX_KEY,
+      []
+    );
+    const merged = [.../* @__PURE__ */ new Set([...existingIndex, ...migratedProviders])];
+    await driver.setItem(PROVIDER_INDEX_KEY, merged);
+    await driver.removeItem(SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS);
+    await driver.removeItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE);
+  }
+  await driver.setItem(MIGRATION_MARKER_KEY4, true);
+  const [
+    rawMints,
+    rawInfo,
+    lastUsedModel,
+    rawDisabled,
+    rawBaseUrls,
+    lastBaseUrlsUpdate,
+    rawRoutstr21Models,
+    lastRoutstr21ModelsUpdate
+  ] = await Promise.all([
+    driver.getItem(
+      SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
+      {}
+    ),
+    driver.getItem(
+      SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS,
+      {}
+    ),
+    driver.getItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, null),
+    driver.getItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, []),
+    driver.getItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, []),
+    driver.getItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, null),
+    driver.getItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, []),
+    driver.getItem(
+      SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE,
+      null
+    )
+  ]);
+  const modelsByBaseUrl = /* @__PURE__ */ new Map();
+  const timestampsByBaseUrl = /* @__PURE__ */ new Map();
+  const providerIndex = /* @__PURE__ */ new Set();
+  const knownProviders = /* @__PURE__ */ new Set();
+  for (const baseUrl of Object.keys(rawInfo)) {
+    knownProviders.add(normalizeBaseUrl6(baseUrl));
+  }
+  for (const baseUrl of Object.keys(rawMints)) {
+    knownProviders.add(normalizeBaseUrl6(baseUrl));
+  }
+  for (const baseUrl of rawBaseUrls) {
+    knownProviders.add(normalizeBaseUrl6(baseUrl));
+  }
+  for (const baseUrl of rawDisabled) {
+    knownProviders.add(normalizeBaseUrl6(baseUrl));
+  }
+  for (const baseUrl of Object.keys(legacyModels)) {
+    knownProviders.add(normalizeBaseUrl6(baseUrl));
+  }
+  const indexProviders = await driver.getItem(
+    PROVIDER_INDEX_KEY,
+    []
+  );
+  for (const baseUrl of indexProviders) {
+    const normalized = normalizeBaseUrl6(baseUrl);
+    providerIndex.add(normalized);
+    knownProviders.add(normalized);
+  }
+  for (const baseUrl of knownProviders) {
+    const normalized = normalizeBaseUrl6(baseUrl);
+    const models = await driver.getItem(
+      modelKey(normalized),
+      null
+    );
+    const ts = await driver.getItem(
+      modelTsKey(normalized),
+      null
+    );
+    if (models !== null) {
+      modelsByBaseUrl.set(normalized, models);
+    }
+    if (ts !== null) {
+      timestampsByBaseUrl.set(normalized, ts);
+    }
+    if (models !== null || ts !== null) {
+      providerIndex.add(normalized);
+    }
+  }
+  let mints = Object.fromEntries(
+    Object.entries(rawMints).map(([baseUrl, mintList]) => [
+      normalizeBaseUrl6(baseUrl),
+      mintList.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
+    ])
+  );
+  let info = Object.fromEntries(
+    Object.entries(rawInfo).map(([baseUrl, entry]) => [
+      normalizeBaseUrl6(baseUrl),
+      entry
+    ])
+  );
+  let _lastUsedModel = lastUsedModel;
+  let _disabledProviders = rawDisabled.map(normalizeBaseUrl6);
+  let _baseUrlsList = rawBaseUrls.map(normalizeBaseUrl6);
+  let _lastBaseUrlsUpdate = lastBaseUrlsUpdate;
+  let _routstr21Models = rawRoutstr21Models;
+  let _lastRoutstr21ModelsUpdate = lastRoutstr21ModelsUpdate;
+  const persistProviderIndex = () => {
+    void driver.setItem(PROVIDER_INDEX_KEY, [...providerIndex]);
+  };
+  return {
+    // -- Models (sharded kv) --
+    getCachedModels: () => {
+      const result = {};
+      for (const [baseUrl, models] of modelsByBaseUrl.entries()) {
+        result[baseUrl] = models;
+      }
+      return result;
+    },
+    setCachedModels: (models) => {
+      const nextKeys = new Set(
+        Object.keys(models).map((baseUrl) => normalizeBaseUrl6(baseUrl))
+      );
+      for (const baseUrl of [...modelsByBaseUrl.keys()]) {
+        if (!nextKeys.has(normalizeBaseUrl6(baseUrl))) {
+          providerIndex.delete(baseUrl);
+          modelsByBaseUrl.delete(baseUrl);
+          timestampsByBaseUrl.delete(baseUrl);
+          void driver.removeItem(modelKey(baseUrl));
+          void driver.removeItem(modelTsKey(baseUrl));
+        }
+      }
+      for (const [baseUrl, modelList] of Object.entries(models)) {
+        const normalized = normalizeBaseUrl6(baseUrl);
+        providerIndex.add(normalized);
+        modelsByBaseUrl.set(normalized, modelList);
+        const ts = timestampsByBaseUrl.get(normalized) ?? Date.now();
+        timestampsByBaseUrl.set(normalized, ts);
+        void driver.setItem(modelKey(normalized), modelList);
+        void driver.setItem(modelTsKey(normalized), ts);
+      }
+      persistProviderIndex();
+    },
+    getProviderLastUpdate: (baseUrl) => {
+      return timestampsByBaseUrl.get(normalizeBaseUrl6(baseUrl)) ?? null;
+    },
+    setProviderLastUpdate: (baseUrl, timestamp) => {
+      const normalized = normalizeBaseUrl6(baseUrl);
+      providerIndex.add(normalized);
+      timestampsByBaseUrl.set(normalized, timestamp);
+      void driver.setItem(modelTsKey(normalized), timestamp);
+      persistProviderIndex();
+    },
+    // -- Mints (kv) --
+    getCachedMints: () => mints,
+    setCachedMints: (value) => {
+      const normalized = {};
+      for (const [baseUrl, mintList] of Object.entries(value)) {
+        normalized[normalizeBaseUrl6(baseUrl)] = mintList.map(
+          (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
+        );
+      }
+      mints = normalized;
+      void driver.setItem(SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS, normalized);
+    },
+    // -- Provider info (kv) --
+    getCachedProviderInfo: () => info,
+    setCachedProviderInfo: (value) => {
+      const normalized = {};
+      for (const [baseUrl, entry] of Object.entries(value)) {
+        normalized[normalizeBaseUrl6(baseUrl)] = entry;
+      }
+      info = normalized;
+      void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
+    },
+    // -- Last used model (kv) --
+    getLastUsedModel: () => _lastUsedModel,
+    setLastUsedModel: (modelId) => {
+      _lastUsedModel = modelId;
+      void driver.setItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, modelId);
+    },
+    // -- Disabled providers (kv) --
+    getDisabledProviders: () => _disabledProviders,
+    setDisabledProviders: (urls) => {
+      const normalized = urls.map(normalizeBaseUrl6);
+      _disabledProviders = normalized;
+      void driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
+    },
+    // -- Base URLs (kv) --
+    getBaseUrlsList: () => _baseUrlsList,
+    getBaseUrlsLastUpdate: () => _lastBaseUrlsUpdate,
+    setBaseUrlsList: (urls) => {
+      const normalized = urls.map(normalizeBaseUrl6);
+      _baseUrlsList = normalized;
+      void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
+    },
+    setBaseUrlsLastUpdate: (timestamp) => {
+      _lastBaseUrlsUpdate = timestamp;
+      void driver.setItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, timestamp);
+    },
+    // -- Routstr21 models (kv) --
+    getRoutstr21Models: () => _routstr21Models,
+    setRoutstr21Models: (models) => {
+      _routstr21Models = models;
+      void driver.setItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, models);
+    },
+    getRoutstr21ModelsLastUpdate: () => _lastRoutstr21ModelsUpdate,
+    setRoutstr21ModelsLastUpdate: (timestamp) => {
+      _lastRoutstr21ModelsUpdate = timestamp;
+      void driver.setItem(
+        SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE,
+        timestamp
+      );
+    }
+  };
+};
+var createProviderRegistryFromDiscoveryAdapter = (adapter, logger) => {
+  const log = (logger ?? consoleLogger).child("ProviderRegistry");
+  return {
+    getModelsForProvider: (baseUrl) => {
+      const normalized = normalizeBaseUrl6(baseUrl);
+      return adapter.getCachedModels()[normalized] || [];
+    },
+    getDisabledProviders: () => adapter.getDisabledProviders(),
+    getProviderMints: (baseUrl) => {
+      const normalized = normalizeBaseUrl6(baseUrl);
+      return adapter.getCachedMints()[normalized] || [];
+    },
+    getProviderInfo: async (baseUrl) => {
+      const normalized = normalizeBaseUrl6(baseUrl);
+      const cached = adapter.getCachedProviderInfo()[normalized];
+      if (cached) return cached;
+      try {
+        const response = await fetch(`${normalized}v1/info`);
+        if (!response.ok) {
+          throw new Error(`Failed ${response.status}`);
+        }
+        const info = await response.json();
+        adapter.setCachedProviderInfo({
+          ...adapter.getCachedProviderInfo(),
+          [normalized]: info
+        });
+        return info;
+      } catch (error) {
+        log.warn(`Failed to fetch provider info from ${normalized}:`, error);
+        return null;
+      }
+    },
+    getAllProvidersModels: () => adapter.getCachedModels()
+  };
+};
+
 // storage/index.ts
 var isBrowser3 = () => {
   try {
@@ -4755,9 +5189,15 @@ var getDefaultUsageTrackingDriver = () => {
 var setDefaultUsageTrackingDriver = (driver) => {
   defaultUsageTrackingDriver = driver;
 };
-var getDefaultDiscoveryAdapter = async () => createDiscoveryAdapterFromStore(await getDefaultSdkStore());
+var defaultDiscoveryAdapter = null;
+var getDefaultDiscoveryAdapter = async () => {
+  if (defaultDiscoveryAdapter) return defaultDiscoveryAdapter;
+  const driver = getDefaultSdkDriver();
+  defaultDiscoveryAdapter = await createShardedDiscoveryAdapter({ driver });
+  return defaultDiscoveryAdapter;
+};
 var getDefaultStorageAdapter = async () => createStorageAdapterFromStore(await getDefaultSdkStore());
-var getDefaultProviderRegistry = async () => createProviderRegistryFromStore(await getDefaultSdkStore());
+var getDefaultProviderRegistry = async () => createProviderRegistryFromDiscoveryAdapter(await getDefaultDiscoveryAdapter());
 function mergeUsage(previous, next) {
   if (!previous) return next;
   return {
@@ -5067,6 +5507,8 @@ var RoutstrClient = class {
         baseUrl: prepared.baseUrlUsed,
         mintUrl: params.mintUrl,
         initialTokenBalance: prepared.tokenBalanceInSats,
+        initialTokenBalanceUnknown: prepared.tokenBalanceUnknown,
+        fallbackSatsSpent: usage?.satsCost,
         response: prepared.response,
         modelId: prepared.modelId,
         usage,
@@ -5131,7 +5573,7 @@ var RoutstrClient = class {
         );
       }
     }
-    const { token, tokenBalance, tokenBalanceUnit } = await this._spendToken({
+    const { token, tokenBalance, tokenBalanceUnit, tokenBalanceUnknown } = await this._spendToken({
       mintUrl,
       amount: requiredSats,
       baseUrl
@@ -5157,9 +5599,20 @@ var RoutstrClient = class {
       baseHeaders,
       selectedModel
     });
-    const tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
+    let tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
+    let initialTokenBalanceUnknown = tokenBalanceUnknown;
     const baseUrlUsed = response.baseUrl || baseUrl;
     const tokenUsed = response.token || token;
+    if (baseUrlUsed !== baseUrl || tokenUsed !== token) {
+      if (typeof response.initialTokenBalanceInSats === "number") {
+        tokenBalanceInSats = response.initialTokenBalanceInSats;
+        initialTokenBalanceUnknown = Boolean(
+          response.initialTokenBalanceUnknown
+        );
+      } else {
+        initialTokenBalanceUnknown = true;
+      }
+    }
     const contentType = response.headers.get("content-type") || "";
     let processedResponse = response;
     let capturedUsage;
@@ -5192,6 +5645,7 @@ var RoutstrClient = class {
       tokenUsed,
       baseUrlUsed,
       tokenBalanceInSats,
+      tokenBalanceUnknown: initialTokenBalanceUnknown,
       modelId,
       capturedUsage,
       capturedResponseId,
@@ -5241,7 +5695,8 @@ var RoutstrClient = class {
       let token = spendResult.token;
       let tokenBalance = spendResult.tokenBalance;
       let tokenBalanceUnit = spendResult.tokenBalanceUnit;
-      const tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
+      let tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
+      let initialTokenBalanceUnknown = spendResult.tokenBalanceUnknown;
       callbacks.onTokenCreated?.(this._getPendingCashuTokenAmount());
       const baseHeaders = this._buildBaseHeaders(headers);
       const requestHeaders = this._withAuthHeader(baseHeaders, token);
@@ -5284,6 +5739,18 @@ var RoutstrClient = class {
       }
       if (response.status === 200) {
         const baseUrlUsed = response.baseUrl || baseUrl;
+        const responseToken = response.token || token;
+        if (baseUrlUsed !== baseUrl || responseToken !== token) {
+          token = responseToken;
+          if (typeof response.initialTokenBalanceInSats === "number") {
+            tokenBalanceInSats = response.initialTokenBalanceInSats;
+            initialTokenBalanceUnknown = Boolean(
+              response.initialTokenBalanceUnknown
+            );
+          } else {
+            initialTokenBalanceUnknown = true;
+          }
+        }
         const streamingResult = await this.streamProcessor.process(
           response,
           {
@@ -5314,6 +5781,7 @@ var RoutstrClient = class {
           baseUrl: baseUrlUsed,
           mintUrl,
           initialTokenBalance: tokenBalanceInSats,
+          initialTokenBalanceUnknown,
           fallbackSatsSpent: isApikeysEstimate ? this._getEstimatedCosts(selectedModel, streamingResult) : void 0,
           response,
           modelId: selectedModel.id,
@@ -5470,14 +5938,24 @@ var RoutstrClient = class {
           params.token,
           baseUrl
         );
-        const currentBalance = currentBalanceInfo.unit === "msat" ? currentBalanceInfo.amount / 1e3 : currentBalanceInfo.amount;
-        const reservedBalance = currentBalanceInfo.unit === "msat" ? (currentBalanceInfo.reserved ?? 0) / 1e3 : currentBalanceInfo.reserved ?? 0;
-        const shortfall = Math.max(0, params.requiredSats - currentBalance + reservedBalance);
-        topupAmount = shortfall > 0.21 * params.requiredSats ? shortfall : 0.21 * params.requiredSats;
-        this._log(
-          "DEBUG",
-          `The shortfall is: ${shortfall}. requiredSats: ${params.requiredSats}. Current Balance: ${currentBalance}. Reserved Balance: ${reservedBalance}. Available Balance: ${currentBalance - reservedBalance}`
-        );
+        if (currentBalanceInfo.balanceUnknown) {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Current balance unknown for ${baseUrl}; using default topup amount=${topupAmount}`
+          );
+        } else {
+          const currentBalance = currentBalanceInfo.unit === "msat" ? currentBalanceInfo.amount / 1e3 : currentBalanceInfo.amount;
+          const reservedBalance = currentBalanceInfo.unit === "msat" ? (currentBalanceInfo.reserved ?? 0) / 1e3 : currentBalanceInfo.reserved ?? 0;
+          const shortfall = Math.max(
+            0,
+            params.requiredSats - currentBalance + reservedBalance
+          );
+          topupAmount = shortfall > 0.21 * params.requiredSats ? shortfall : 0.21 * params.requiredSats;
+          this._log(
+            "DEBUG",
+            `The shortfall is: ${shortfall}. requiredSats: ${params.requiredSats}. Current Balance: ${currentBalance}. Reserved Balance: ${reservedBalance}. Available Balance: ${currentBalance - reservedBalance}`
+          );
+        }
       } catch (e) {
         this._log(
           "WARN",
@@ -5563,7 +6041,7 @@ var RoutstrClient = class {
           this.storageAdapter.removeApiKey(baseUrl);
           tryNextProvider = true;
         } else {
-          const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
+          const latestTokenBalance = latestBalanceInfo.balanceUnknown ? void 0 : latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
           if (latestBalanceInfo.apiKey) {
             const storedApiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
             if (storedApiKeyEntry?.key !== latestBalanceInfo.apiKey) {
@@ -5574,7 +6052,7 @@ var RoutstrClient = class {
             }
             retryToken = latestBalanceInfo.apiKey;
           }
-          if (latestTokenBalance >= 0) {
+          if (latestTokenBalance !== void 0 && latestTokenBalance >= 0) {
             this.storageAdapter.updateApiKeyBalance(
               baseUrl,
               latestTokenBalance
@@ -5649,7 +6127,7 @@ var RoutstrClient = class {
           "DEBUG",
           `[RoutstrClient] _handleErrorResponse: API key refund result: success=${refundResult.success}, message=${refundResult.message}`
         );
-        if (!refundResult.success && latestBalanceInfo.amount > 0) {
+        if (!refundResult.success && latestBalanceInfo.amount > 0 && !latestBalanceInfo.balanceUnknown) {
           throw new ProviderError(
             baseUrl,
             status,
@@ -5700,7 +6178,7 @@ var RoutstrClient = class {
         amount: newRequiredSats,
         baseUrl: nextProvider
       });
-      return this._makeRequest({
+      const retryResponse = await this._makeRequest({
         ...params,
         path,
         method,
@@ -5712,6 +6190,9 @@ var RoutstrClient = class {
         headers: this._withAuthHeader(params.baseHeaders, spendResult.token),
         retryCount: 0
       });
+      retryResponse.initialTokenBalanceInSats = spendResult.tokenBalanceUnit === "msat" ? spendResult.tokenBalance / 1e3 : spendResult.tokenBalance;
+      retryResponse.initialTokenBalanceUnknown = spendResult.tokenBalanceUnknown;
+      return retryResponse;
     }
     throw new FailoverError(
       baseUrl,
@@ -5727,6 +6208,7 @@ var RoutstrClient = class {
       baseUrl,
       mintUrl,
       initialTokenBalance,
+      initialTokenBalanceUnknown,
       fallbackSatsSpent,
       response,
       modelId,
@@ -5763,17 +6245,19 @@ var RoutstrClient = class {
           latestBalanceInfo.apiKey,
           baseUrl
         );
-        const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
+        const latestTokenBalance = latestBalanceInfo.balanceUnknown ? void 0 : latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
         const storedApiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
         if (storedApiKeyEntry?.key.startsWith("cashu") && latestBalanceInfo.apiKey) {
           this.storageAdapter.removeApiKey(baseUrl);
           this.storageAdapter.setApiKey(baseUrl, latestBalanceInfo.apiKey);
         }
-        this.storageAdapter.updateApiKeyBalance(baseUrl, latestTokenBalance);
-        satsSpent = initialTokenBalance - latestTokenBalance;
+        if (latestTokenBalance !== void 0) {
+          this.storageAdapter.updateApiKeyBalance(baseUrl, latestTokenBalance);
+        }
+        satsSpent = latestTokenBalance !== void 0 && !initialTokenBalanceUnknown ? Math.max(0, initialTokenBalance - latestTokenBalance) : fallbackSatsSpent ?? usage?.satsCost ?? 0;
       } catch (e) {
         this._log("WARN", "Could not get updated API key balance:", e);
-        satsSpent = fallbackSatsSpent ?? initialTokenBalance;
+        satsSpent = fallbackSatsSpent ?? usage?.satsCost ?? 0;
       }
     }
     await this._trackResponseUsage({
@@ -6023,6 +6507,7 @@ var RoutstrClient = class {
       }
       let tokenBalance = 0;
       let tokenBalanceUnit = "sat";
+      let tokenBalanceUnknown = false;
       const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
       const distributionForBaseUrl = apiKeyDistribution.find(
         (d) => d.baseUrl === baseUrl
@@ -6038,6 +6523,7 @@ var RoutstrClient = class {
           );
           tokenBalance = balanceInfo.amount;
           tokenBalanceUnit = balanceInfo.unit;
+          tokenBalanceUnknown = Boolean(balanceInfo.balanceUnknown);
         } catch (e) {
           this._log("WARN", "Could not get initial API key balance:", e);
         }
@@ -6049,7 +6535,8 @@ var RoutstrClient = class {
       return {
         token: parentApiKey?.key ?? "",
         tokenBalance,
-        tokenBalanceUnit
+        tokenBalanceUnit,
+        tokenBalanceUnknown
       };
     }
     this._log(
@@ -6078,7 +6565,8 @@ var RoutstrClient = class {
     return {
       token: spendResult.token,
       tokenBalance: spendResult.balance,
-      tokenBalanceUnit: spendResult.unit ?? "sat"
+      tokenBalanceUnit: spendResult.unit ?? "sat",
+      tokenBalanceUnknown: false
     };
   }
   /**
@@ -6281,9 +6769,11 @@ exports.createIndexedDBDriver = createIndexedDBDriver;
 exports.createIndexedDBUsageTrackingDriver = createIndexedDBUsageTrackingDriver;
 exports.createMemoryDriver = createMemoryDriver;
 exports.createMemoryUsageTrackingDriver = createMemoryUsageTrackingDriver;
+exports.createProviderRegistryFromDiscoveryAdapter = createProviderRegistryFromDiscoveryAdapter;
 exports.createProviderRegistryFromStore = createProviderRegistryFromStore;
 exports.createSSEParserTransform = createSSEParserTransform;
 exports.createSdkStore = createSdkStore;
+exports.createShardedDiscoveryAdapter = createShardedDiscoveryAdapter;
 exports.createSqliteDriver = createSqliteDriver;
 exports.createSqliteUsageTrackingDriver = createSqliteUsageTrackingDriver;
 exports.createStorageAdapterFromStore = createStorageAdapterFromStore;