@routstr/sdk 0.1.7 → 0.2.0

package/dist/index.js

@@ -15,9 +15,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 
 // core/errors.ts
 var InsufficientBalanceError = class extends Error {
-  constructor(required, available, maxMintBalance = 0, maxMintUrl = "") {
+  constructor(required, available, maxMintBalance = 0, maxMintUrl = "", customMessage) {
     super(
-      `Insufficient balance: need ${required} sats, have ${available} sats available. ` + (maxMintBalance > 0 ? `Largest mint balance: ${maxMintBalance} sats from ${maxMintUrl}` : "")
+      customMessage ?? `Insufficient balance: need ${required} sats, have ${available} sats available. ` + (maxMintBalance > 0 ? `Largest mint balance: ${maxMintBalance} sats from ${maxMintUrl}` : "")
     );
     this.required = required;
     this.available = available;
@@ -301,9 +301,10 @@ var ModelManager = class _ModelManager {
    * Uses cache if available and not expired
    * @param baseUrls List of provider base URLs to fetch from
    * @param forceRefresh Ignore cache and fetch fresh data
+   * @param onProgress Callback fired after each provider completes with current combined models
    * @returns Array of unique models with best prices selected
    */
-  async fetchModels(baseUrls, forceRefresh = false) {
+  async fetchModels(baseUrls, forceRefresh = false, onProgress) {
     if (baseUrls.length === 0) {
       throw new NoProvidersAvailableError();
     }
@@ -313,6 +314,12 @@ var ModelManager = class _ModelManager {
     const estimateMinCost = (m) => {
       return m?.sats_pricing?.completion ?? 0;
     };
+    const emitProgress = () => {
+      if (onProgress) {
+        const currentModels = Array.from(bestById.values()).map((v) => v.model);
+        onProgress(currentModels);
+      }
+    };
     const fetchPromises = baseUrls.map(async (url) => {
       const base = url.endsWith("/") ? url : `${url}/`;
       try {
@@ -347,6 +354,7 @@ var ModelManager = class _ModelManager {
             }
           }
         }
+        emitProgress();
         return { success: true, base, list };
       } catch (error) {
         if (this.isProviderDownError(error)) {
@@ -768,6 +776,9 @@ var CashuSpender = class {
     return result;
   }
   async _getBalanceState() {
+    if (this.balanceManager) {
+      return this.balanceManager.getBalanceState();
+    }
     const mintBalances = await this.walletAdapter.getBalances();
     const units = this.walletAdapter.getMintUnits();
     let totalMintBalance = 0;
@@ -783,15 +794,16 @@ var CashuSpender = class {
     const providerBalances = {};
     let totalProviderBalance = 0;
     for (const pending of pendingDistribution) {
-      providerBalances[pending.baseUrl] = pending.amount;
+      providerBalances[pending.baseUrl] = (providerBalances[pending.baseUrl] || 0) + pending.amount;
       totalProviderBalance += pending.amount;
     }
     const apiKeys = this.storageAdapter.getAllApiKeys();
     for (const apiKey of apiKeys) {
       if (!providerBalances[apiKey.baseUrl]) {
-        providerBalances[apiKey.baseUrl] = apiKey.balance;
-        totalProviderBalance += apiKey.balance;
+        providerBalances[apiKey.baseUrl] = 0;
       }
+      providerBalances[apiKey.baseUrl] += apiKey.balance;
+      totalProviderBalance += apiKey.balance;
     }
     return {
       totalBalance: totalMintBalance + totalProviderBalance,
@@ -940,25 +952,12 @@ var CashuSpender = class {
         `[CashuSpender] _spendInternal: Could not reuse token, will create new token`
       );
     }
-    const balances = await this.walletAdapter.getBalances();
-    const units = this.walletAdapter.getMintUnits();
-    let totalBalance = 0;
-    for (const url in balances) {
-      const balance = balances[url];
-      const unit = units[url];
-      const balanceInSats = getBalanceInSats(balance, unit);
-      totalBalance += balanceInSats;
-    }
-    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
-    const totalPending = pendingDistribution.reduce(
-      (sum, item) => sum + item.amount,
-      0
-    );
+    const balanceState = await this._getBalanceState();
+    const totalAvailableBalance = balanceState.totalBalance;
     this._log(
       "DEBUG",
-      `[CashuSpender] _spendInternal: totalBalance=${totalBalance}, totalPending=${totalPending}, adjustedAmount=${adjustedAmount}`
+      `[CashuSpender] _spendInternal: totalAvailableBalance=${totalAvailableBalance}, adjustedAmount=${adjustedAmount}`
     );
-    const totalAvailableBalance = totalBalance + totalPending;
     if (totalAvailableBalance < adjustedAmount) {
       this._log(
         "ERROR",
@@ -966,8 +965,7 @@ var CashuSpender = class {
       );
       return this._createInsufficientBalanceError(
         adjustedAmount,
-        balances,
-        units,
+        balanceState.mintBalances,
         totalAvailableBalance
       );
     }
@@ -987,8 +985,7 @@ var CashuSpender = class {
         if ((tokenResult.error || "").includes("Insufficient balance")) {
           return this._createInsufficientBalanceError(
             adjustedAmount,
-            balances,
-            units,
+            balanceState.mintBalances,
             totalAvailableBalance
           );
         }
@@ -1033,6 +1030,7 @@ var CashuSpender = class {
       "DEBUG",
       `[CashuSpender] _spendInternal: Successfully spent ${spentAmount}, returning token with balance=${spentAmount}`
     );
+    const units = this.walletAdapter.getMintUnits();
     return {
       token,
       status: "success",
@@ -1170,13 +1168,11 @@ var CashuSpender = class {
   /**
    * Create an insufficient balance error result
    */
-  _createInsufficientBalanceError(required, balances, units, availableBalance) {
+  _createInsufficientBalanceError(required, normalizedBalances, availableBalance) {
     let maxBalance = 0;
     let maxMintUrl = "";
-    for (const mintUrl in balances) {
-      const balance = balances[mintUrl];
-      const unit = units[mintUrl];
-      const balanceInSats = getBalanceInSats(balance, unit);
+    for (const mintUrl in normalizedBalances) {
+      const balanceInSats = normalizedBalances[mintUrl];
       if (balanceInSats > maxBalance) {
         maxBalance = balanceInSats;
         maxMintUrl = mintUrl;
@@ -1237,6 +1233,39 @@ var BalanceManager = class {
     }
   }
   cashuSpender;
+  async getBalanceState() {
+    const mintBalances = await this.walletAdapter.getBalances();
+    const units = this.walletAdapter.getMintUnits();
+    let totalMintBalance = 0;
+    const normalizedMintBalances = {};
+    for (const url in mintBalances) {
+      const balance = mintBalances[url];
+      const unit = units[url];
+      const balanceInSats = getBalanceInSats(balance, unit);
+      normalizedMintBalances[url] = balanceInSats;
+      totalMintBalance += balanceInSats;
+    }
+    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
+    const providerBalances = {};
+    let totalProviderBalance = 0;
+    for (const pending of pendingDistribution) {
+      providerBalances[pending.baseUrl] = (providerBalances[pending.baseUrl] || 0) + pending.amount;
+      totalProviderBalance += pending.amount;
+    }
+    const apiKeys = this.storageAdapter.getAllApiKeys();
+    for (const apiKey of apiKeys) {
+      if (!providerBalances[apiKey.baseUrl]) {
+        providerBalances[apiKey.baseUrl] = 0;
+      }
+      providerBalances[apiKey.baseUrl] += apiKey.balance;
+      totalProviderBalance += apiKey.balance;
+    }
+    return {
+      totalBalance: totalMintBalance + totalProviderBalance,
+      providerBalances,
+      mintBalances: normalizedMintBalances
+    };
+  }
   /**
    * Unified refund - handles both NIP-60 and legacy wallet refunds
    */
@@ -1447,6 +1476,10 @@ var BalanceManager = class {
         requestId
       };
     } catch (error) {
+      console.log(
+        "DEBUG",
+        `[TopuPU] topup: Topup result for ${baseUrl}: error=${error}`
+      );
       if (cashuToken) {
         await this._recoverFailedTopUp(cashuToken);
       }
@@ -1466,23 +1499,42 @@ var BalanceManager = class {
     if (!adjustedAmount || isNaN(adjustedAmount)) {
       return { success: false, error: "Invalid top up amount" };
     }
+    const balanceState = await this.getBalanceState();
     const balances = await this.walletAdapter.getBalances();
     const units = this.walletAdapter.getMintUnits();
-    let totalMintBalance = 0;
-    for (const url in balances) {
-      const unit = units[url];
-      const balanceInSats = getBalanceInSats(balances[url], unit);
-      totalMintBalance += balanceInSats;
-    }
-    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
-    const refundablePending = pendingDistribution.filter((entry) => entry.baseUrl !== baseUrl).reduce((sum, entry) => sum + entry.amount, 0);
-    if (totalMintBalance < adjustedAmount && totalMintBalance + refundablePending >= adjustedAmount && retryCount < 1) {
+    const totalMintBalance = Object.values(balanceState.mintBalances).reduce(
+      (sum, value) => sum + value,
+      0
+    );
+    const targetProviderBalance = balanceState.providerBalances[baseUrl] || 0;
+    const refundableProviderBalance = Object.entries(
+      balanceState.providerBalances
+    ).filter(([providerBaseUrl]) => providerBaseUrl !== baseUrl).reduce((sum, [, value]) => sum + value, 0);
+    if (totalMintBalance + targetProviderBalance < adjustedAmount && totalMintBalance + targetProviderBalance + refundableProviderBalance >= adjustedAmount && retryCount < 1) {
       await this._refundOtherProvidersForTopUp(baseUrl, mintUrl);
       return this.createProviderToken({
         ...options,
         retryCount: retryCount + 1
       });
     }
+    if (totalMintBalance + targetProviderBalance < adjustedAmount) {
+      const error = new InsufficientBalanceError(
+        adjustedAmount,
+        totalMintBalance + targetProviderBalance,
+        totalMintBalance,
+        Object.entries(balanceState.mintBalances).reduce(
+          (max, [url, balance]) => balance > max.balance ? { url, balance } : max,
+          { url: "", balance: 0 }
+        ).url
+      );
+      return { success: false, error: error.message };
+    }
+    if (targetProviderBalance >= adjustedAmount) {
+      return {
+        success: true,
+        amountSpent: 0
+      };
+    }
     const providerMints = baseUrl && this.providerRegistry ? this.providerRegistry.getProviderMints(baseUrl) : [];
     let requiredAmount = adjustedAmount;
     const supportedMintsOnly = providerMints.length > 0;
@@ -1598,10 +1650,14 @@ var BalanceManager = class {
   }
   async _refundOtherProvidersForTopUp(baseUrl, mintUrl) {
     const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
+    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
     const toRefund = pendingDistribution.filter(
       (pending) => pending.baseUrl !== baseUrl
     );
-    const refundResults = await Promise.allSettled(
+    const apiKeysToRefund = apiKeyDistribution.filter(
+      (apiKey) => apiKey.baseUrl !== baseUrl && apiKey.amount > 0
+    );
+    const tokenRefundResults = await Promise.allSettled(
       toRefund.map(async (pending) => {
         const token = this.storageAdapter.getToken(pending.baseUrl);
         if (!token) {
@@ -1619,11 +1675,32 @@ var BalanceManager = class {
         return { baseUrl: pending.baseUrl, success: result.success };
       })
     );
-    for (const result of refundResults) {
+    for (const result of tokenRefundResults) {
       if (result.status === "fulfilled" && result.value.success) {
         this.storageAdapter.removeToken(result.value.baseUrl);
       }
     }
+    const apiKeyRefundResults = await Promise.allSettled(
+      apiKeysToRefund.map(async (apiKeyEntry) => {
+        const fullApiKeyEntry = this.storageAdapter.getApiKey(
+          apiKeyEntry.baseUrl
+        );
+        if (!fullApiKeyEntry) {
+          return { baseUrl: apiKeyEntry.baseUrl, success: false };
+        }
+        const result = await this.refundApiKey({
+          mintUrl,
+          baseUrl: apiKeyEntry.baseUrl,
+          apiKey: fullApiKeyEntry.key
+        });
+        return { baseUrl: apiKeyEntry.baseUrl, success: result.success };
+      })
+    );
+    for (const result of apiKeyRefundResults) {
+      if (result.status === "fulfilled" && result.value.success) {
+        this.storageAdapter.updateApiKeyBalance(result.value.baseUrl, 0);
+      }
+    }
   }
   /**
    * Fetch refund token from provider API
@@ -2874,10 +2951,34 @@ var RoutstrClient = class {
       }
     }
     if (status === 402 && !tryNextProvider && (this.mode === "apikeys" || this.mode === "lazyrefund")) {
+      this.storageAdapter.getApiKey(baseUrl);
+      let topupAmount = params.requiredSats;
+      try {
+        let currentBalance = 0;
+        if (this.mode === "apikeys") {
+          const currentBalanceInfo = await this.balanceManager.getTokenBalance(
+            params.token,
+            baseUrl
+          );
+          currentBalance = currentBalanceInfo.unit === "msat" ? currentBalanceInfo.amount / 1e3 : currentBalanceInfo.amount;
+        } else if (this.mode === "lazyrefund") {
+          const distribution = this.storageAdapter.getCachedTokenDistribution();
+          const tokenEntry = distribution.find((t) => t.baseUrl === baseUrl);
+          currentBalance = tokenEntry?.amount ?? 0;
+        }
+        const shortfall = Math.max(0, params.requiredSats - currentBalance);
+        topupAmount = shortfall > 0 ? shortfall : params.requiredSats;
+      } catch (e) {
+        this._log(
+          "WARN",
+          "Could not get current token balance for topup calculation:",
+          e
+        );
+      }
       const topupResult = await this.balanceManager.topUp({
         mintUrl,
         baseUrl,
-        amount: params.requiredSats * TOPUP_MARGIN,
+        amount: topupAmount * TOPUP_MARGIN,
         token: params.token
       });
       this._log(
@@ -2895,7 +2996,7 @@ var RoutstrClient = class {
             "DEBUG",
             `[RoutstrClient] _handleErrorResponse: Insufficient balance, need=${required}, have=${available}`
           );
-          throw new InsufficientBalanceError(required, available);
+          throw new InsufficientBalanceError(required, available, 0, "", message);
         } else {
           this._log(
             "DEBUG",
@@ -2958,7 +3059,10 @@ var RoutstrClient = class {
             retryToken = latestBalanceInfo.apiKey;
           }
           if (latestTokenBalance >= 0) {
-            this.storageAdapter.updateApiKeyBalance(baseUrl, latestTokenBalance);
+            this.storageAdapter.updateApiKeyBalance(
+              baseUrl,
+              latestTokenBalance
+            );
           }
         }
       } catch (error) {
@@ -3628,7 +3732,11 @@ var createSqliteDriver = (options = {}) => {
 };
 
 // storage/drivers/indexedDB.ts
+var isBrowser = typeof indexedDB !== "undefined";
 var openDatabase = (dbName, storeName) => {
+  if (!isBrowser) {
+    return Promise.reject(new Error("IndexedDB is not available"));
+  }
   return new Promise((resolve, reject) => {
     const request = indexedDB.open(dbName, 1);
     request.onupgradeneeded = () => {
@@ -3732,7 +3840,9 @@ var SDK_STORAGE_KEYS = {
   CHILD_KEYS: "child_keys",
   ROUTSTR21_MODELS: "routstr21Models",
   LAST_ROUTSTR21_MODELS_UPDATE: "lastRoutstr21ModelsUpdate",
-  CACHED_RECEIVE_TOKENS: "cached_receive_tokens"
+  CACHED_RECEIVE_TOKENS: "cached_receive_tokens",
+  USAGE_TRACKING: "usage_tracking",
+  CLIENT_IDS: "client_ids"
 };
 
 // storage/store.ts
@@ -3750,9 +3860,159 @@ var getCashuTokenBalance = (token) => {
     return 0;
   }
 };
-var createSdkStore = async ({
-  driver
-}) => {
+var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
+  modelsFromAllProviders: {},
+  lastUsedModel: null,
+  baseUrlsList: [],
+  lastBaseUrlsUpdate: null,
+  disabledProviders: [],
+  mintsFromAllProviders: {},
+  infoFromAllProviders: {},
+  lastModelsUpdate: {},
+  cachedTokens: [],
+  apiKeys: [],
+  childKeys: [],
+  routstr21Models: [],
+  lastRoutstr21ModelsUpdate: null,
+  cachedReceiveTokens: [],
+  usageTracking: [],
+  clientIds: [],
+  setModelsFromAllProviders: (value) => {
+    const normalized = {};
+    for (const [baseUrl, models] of Object.entries(value)) {
+      normalized[normalizeBaseUrl(baseUrl)] = models;
+    }
+    void driver.setItem(
+      SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
+      normalized
+    );
+    set({ modelsFromAllProviders: normalized });
+  },
+  setLastUsedModel: (value) => {
+    void driver.setItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, value);
+    set({ lastUsedModel: value });
+  },
+  setBaseUrlsList: (value) => {
+    const normalized = value.map((url) => normalizeBaseUrl(url));
+    void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
+    set({ baseUrlsList: normalized });
+  },
+  setBaseUrlsLastUpdate: (value) => {
+    void driver.setItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, value);
+    set({ lastBaseUrlsUpdate: value });
+  },
+  setDisabledProviders: (value) => {
+    const normalized = value.map((url) => normalizeBaseUrl(url));
+    void driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
+    set({ disabledProviders: normalized });
+  },
+  setMintsFromAllProviders: (value) => {
+    const normalized = {};
+    for (const [baseUrl, mints] of Object.entries(value)) {
+      normalized[normalizeBaseUrl(baseUrl)] = mints.map(
+        (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
+      );
+    }
+    void driver.setItem(
+      SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
+      normalized
+    );
+    set({ mintsFromAllProviders: normalized });
+  },
+  setInfoFromAllProviders: (value) => {
+    const normalized = {};
+    for (const [baseUrl, info] of Object.entries(value)) {
+      normalized[normalizeBaseUrl(baseUrl)] = info;
+    }
+    void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
+    set({ infoFromAllProviders: normalized });
+  },
+  setLastModelsUpdate: (value) => {
+    const normalized = {};
+    for (const [baseUrl, timestamp] of Object.entries(value)) {
+      normalized[normalizeBaseUrl(baseUrl)] = timestamp;
+    }
+    void driver.setItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE, normalized);
+    set({ lastModelsUpdate: normalized });
+  },
+  setCachedTokens: (value) => {
+    set((state) => {
+      const updates = typeof value === "function" ? value(state.cachedTokens) : value;
+      const normalized = updates.map((entry) => ({
+        ...entry,
+        baseUrl: normalizeBaseUrl(entry.baseUrl),
+        balance: typeof entry.balance === "number" ? entry.balance : getCashuTokenBalance(entry.token),
+        lastUsed: entry.lastUsed ?? null
+      }));
+      void driver.setItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, normalized);
+      return { cachedTokens: normalized };
+    });
+  },
+  setApiKeys: (value) => {
+    set((state) => {
+      const updates = typeof value === "function" ? value(state.apiKeys) : value;
+      const normalized = updates.map((entry) => ({
+        ...entry,
+        baseUrl: normalizeBaseUrl(entry.baseUrl),
+        balance: entry.balance ?? 0,
+        lastUsed: entry.lastUsed ?? null
+      }));
+      void driver.setItem(SDK_STORAGE_KEYS.API_KEYS, normalized);
+      return { apiKeys: normalized };
+    });
+  },
+  setChildKeys: (value) => {
+    set((state) => {
+      const updates = typeof value === "function" ? value(state.childKeys) : value;
+      const normalized = updates.map((entry) => ({
+        parentBaseUrl: normalizeBaseUrl(entry.parentBaseUrl),
+        childKey: entry.childKey,
+        balance: entry.balance ?? 0,
+        balanceLimit: entry.balanceLimit,
+        validityDate: entry.validityDate,
+        createdAt: entry.createdAt ?? Date.now()
+      }));
+      void driver.setItem(SDK_STORAGE_KEYS.CHILD_KEYS, normalized);
+      return { childKeys: normalized };
+    });
+  },
+  setRoutstr21Models: (value) => {
+    void driver.setItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, value);
+    set({ routstr21Models: value });
+  },
+  setRoutstr21ModelsLastUpdate: (value) => {
+    void driver.setItem(SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE, value);
+    set({ lastRoutstr21ModelsUpdate: value });
+  },
+  setCachedReceiveTokens: (value) => {
+    const normalized = value.map((entry) => ({
+      token: entry.token,
+      amount: entry.amount,
+      unit: entry.unit || "sat",
+      createdAt: entry.createdAt ?? Date.now()
+    }));
+    void driver.setItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, normalized);
+    set({ cachedReceiveTokens: normalized });
+  },
+  setUsageTracking: (value) => {
+    void driver.setItem(SDK_STORAGE_KEYS.USAGE_TRACKING, value);
+    set({ usageTracking: value });
+  },
+  setClientIds: (value) => {
+    set((state) => {
+      const updates = typeof value === "function" ? value(state.clientIds) : value;
+      const normalized = updates.map((entry) => ({
+        ...entry,
+        baseUrl: normalizeBaseUrl(entry.baseUrl),
+        createdAt: entry.createdAt ?? Date.now(),
+        lastUsed: entry.lastUsed ?? null
+      }));
+      void driver.setItem(SDK_STORAGE_KEYS.CLIENT_IDS, normalized);
+      return { clientIds: normalized };
+    });
+  }
+}));
+var hydrateStoreFromDriver = async (store, driver) => {
   const [
     rawModels,
     lastUsedModel,
@@ -3767,7 +4027,9 @@ var createSdkStore = async ({
     rawChildKeys,
     rawRoutstr21Models,
     rawLastRoutstr21ModelsUpdate,
-    rawCachedReceiveTokens
+    rawCachedReceiveTokens,
+    rawUsageTracking,
+    rawClientIds
   ] = await Promise.all([
     driver.getItem(
       SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
@@ -3797,7 +4059,9 @@ var createSdkStore = async ({
       SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE,
       null
     ),
-    driver.getItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, [])
+    driver.getItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, []),
+    driver.getItem(SDK_STORAGE_KEYS.USAGE_TRACKING, []),
+    driver.getItem(SDK_STORAGE_KEYS.CLIENT_IDS, [])
   ]);
   const modelsFromAllProviders = Object.fromEntries(
     Object.entries(rawModels).map(([baseUrl, models]) => [
@@ -3855,7 +4119,14 @@ var createSdkStore = async ({
     unit: entry.unit || "sat",
     createdAt: entry.createdAt ?? Date.now()
   }));
-  return vanilla.createStore((set, get) => ({
+  const usageTracking = rawUsageTracking;
+  const clientIds = rawClientIds.map((entry) => ({
+    ...entry,
+    baseUrl: normalizeBaseUrl(entry.baseUrl),
+    createdAt: entry.createdAt ?? Date.now(),
+    lastUsed: entry.lastUsed ?? null
+  }));
+  store.setState({
     modelsFromAllProviders,
     lastUsedModel,
     baseUrlsList,
@@ -3870,124 +4141,18 @@ var createSdkStore = async ({
     routstr21Models,
     lastRoutstr21ModelsUpdate,
     cachedReceiveTokens,
-    setModelsFromAllProviders: (value) => {
-      const normalized = {};
-      for (const [baseUrl, models] of Object.entries(value)) {
-        normalized[normalizeBaseUrl(baseUrl)] = models;
-      }
-      void driver.setItem(
-        SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
-        normalized
-      );
-      set({ modelsFromAllProviders: normalized });
-    },
-    setLastUsedModel: (value) => {
-      void driver.setItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, value);
-      set({ lastUsedModel: value });
-    },
-    setBaseUrlsList: (value) => {
-      const normalized = value.map((url) => normalizeBaseUrl(url));
-      void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
-      set({ baseUrlsList: normalized });
-    },
-    setBaseUrlsLastUpdate: (value) => {
-      void driver.setItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, value);
-      set({ lastBaseUrlsUpdate: value });
-    },
-    setDisabledProviders: (value) => {
-      const normalized = value.map((url) => normalizeBaseUrl(url));
-      void driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
-      set({ disabledProviders: normalized });
-    },
-    setMintsFromAllProviders: (value) => {
-      const normalized = {};
-      for (const [baseUrl, mints] of Object.entries(value)) {
-        normalized[normalizeBaseUrl(baseUrl)] = mints.map(
-          (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
-        );
-      }
-      void driver.setItem(
-        SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
-        normalized
-      );
-      set({ mintsFromAllProviders: normalized });
-    },
-    setInfoFromAllProviders: (value) => {
-      const normalized = {};
-      for (const [baseUrl, info] of Object.entries(value)) {
-        normalized[normalizeBaseUrl(baseUrl)] = info;
-      }
-      void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
-      set({ infoFromAllProviders: normalized });
-    },
-    setLastModelsUpdate: (value) => {
-      const normalized = {};
-      for (const [baseUrl, timestamp] of Object.entries(value)) {
-        normalized[normalizeBaseUrl(baseUrl)] = timestamp;
-      }
-      void driver.setItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE, normalized);
-      set({ lastModelsUpdate: normalized });
-    },
-    setCachedTokens: (value) => {
-      set((state) => {
-        const updates = typeof value === "function" ? value(state.cachedTokens) : value;
-        const normalized = updates.map((entry) => ({
-          ...entry,
-          baseUrl: normalizeBaseUrl(entry.baseUrl),
-          balance: typeof entry.balance === "number" ? entry.balance : getCashuTokenBalance(entry.token),
-          lastUsed: entry.lastUsed ?? null
-        }));
-        void driver.setItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, normalized);
-        return { cachedTokens: normalized };
-      });
-    },
-    setApiKeys: (value) => {
-      set((state) => {
-        const updates = typeof value === "function" ? value(state.apiKeys) : value;
-        const normalized = updates.map((entry) => ({
-          ...entry,
-          baseUrl: normalizeBaseUrl(entry.baseUrl),
-          balance: entry.balance ?? 0,
-          lastUsed: entry.lastUsed ?? null
-        }));
-        void driver.setItem(SDK_STORAGE_KEYS.API_KEYS, normalized);
-        return { apiKeys: normalized };
-      });
-    },
-    setChildKeys: (value) => {
-      set((state) => {
-        const updates = typeof value === "function" ? value(state.childKeys) : value;
-        const normalized = updates.map((entry) => ({
-          parentBaseUrl: normalizeBaseUrl(entry.parentBaseUrl),
-          childKey: entry.childKey,
-          balance: entry.balance ?? 0,
-          balanceLimit: entry.balanceLimit,
-          validityDate: entry.validityDate,
-          createdAt: entry.createdAt ?? Date.now()
-        }));
-        void driver.setItem(SDK_STORAGE_KEYS.CHILD_KEYS, normalized);
-        return { childKeys: normalized };
-      });
-    },
-    setRoutstr21Models: (value) => {
-      void driver.setItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, value);
-      set({ routstr21Models: value });
-    },
-    setRoutstr21ModelsLastUpdate: (value) => {
-      void driver.setItem(SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE, value);
-      set({ lastRoutstr21ModelsUpdate: value });
-    },
-    setCachedReceiveTokens: (value) => {
-      const normalized = value.map((entry) => ({
-        token: entry.token,
-        amount: entry.amount,
-        unit: entry.unit || "sat",
-        createdAt: entry.createdAt ?? Date.now()
-      }));
-      void driver.setItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, normalized);
-      set({ cachedReceiveTokens: normalized });
-    }
-  }));
+    usageTracking,
+    clientIds
+  });
+};
+var createSdkStore = ({
+  driver
+}) => {
+  const store = createEmptyStore(driver);
+  return {
+    store,
+    hydrate: hydrateStoreFromDriver(store, driver)
+  };
 };
 var createDiscoveryAdapterFromStore = (store) => ({
   getCachedModels: () => store.getState().modelsFromAllProviders,
@@ -4252,7 +4417,7 @@ var createProviderRegistryFromStore = (store) => ({
 });
 
 // storage/index.ts
-var isBrowser = () => {
+var isBrowser2 = () => {
   try {
     return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
   } catch {
@@ -4272,7 +4437,7 @@ var isBun2 = () => {
 };
 var getDefaultSdkDriver = () => {
   if (defaultDriver) return defaultDriver;
-  if (isBrowser()) {
+  if (isBrowser2()) {
     defaultDriver = localStorageDriver;
     return defaultDriver;
   }
@@ -4287,12 +4452,12 @@ var getDefaultSdkDriver = () => {
   defaultDriver = createMemoryDriver();
   return defaultDriver;
 };
-var defaultStorePromise = null;
+var defaultStore = null;
 var getDefaultSdkStore = () => {
-  if (!defaultStorePromise) {
-    defaultStorePromise = createSdkStore({ driver: getDefaultSdkDriver() });
+  if (!defaultStore) {
+    defaultStore = createSdkStore({ driver: getDefaultSdkDriver() });
   }
-  return defaultStorePromise;
+  return defaultStore.hydrate.then(() => defaultStore.store);
 };
 var getDefaultDiscoveryAdapter = async () => createDiscoveryAdapterFromStore(await getDefaultSdkStore());
 var getDefaultStorageAdapter = async () => createStorageAdapterFromStore(await getDefaultSdkStore());
@@ -4313,7 +4478,8 @@ async function routeRequests(options) {
     torMode = false,
     forceRefresh = false,
     modelManager: providedModelManager,
-    debugLevel
+    debugLevel,
+    mode = "apikeys"
   } = options;
   let modelManager;
   let providers;
@@ -4378,7 +4544,7 @@ async function routeRequests(options) {
     storageAdapter,
     providerRegistry,
     alertLevel,
-    "apikeys"
+    mode
   );
   if (debugLevel) {
     client.setDebugLevel(debugLevel);