@routstr/sdk 0.2.5 → 0.2.7

package/dist/index.js

@@ -4,16 +4,8 @@ var applesauceRelay = require('applesauce-relay');
 var applesauceCore = require('applesauce-core');
 var rxjs = require('rxjs');
 var vanilla = require('zustand/vanilla');
-var cashuTs = require('@cashu/cashu-ts');
 var stream = require('stream');
 
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
 // core/errors.ts
 var InsufficientBalanceError = class extends Error {
   constructor(required, available, maxMintBalance = 0, maxMintUrl = "", customMessage) {
@@ -476,7 +468,7 @@ var ModelManager = class _ModelManager {
       }
     }
     const DEFAULT_RELAYS = [
-      "wss://relay.primal.net",
+      "wss://relay.damus.io",
       "wss://nos.lol",
       "wss://relay.routstr.com"
     ];
@@ -788,13 +780,8 @@ var CashuSpender = class {
       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]) {
@@ -1015,27 +1002,11 @@ var CashuSpender = class {
         };
       }
     }
-    if (token && baseUrl) {
-      try {
-        this.storageAdapter.setToken(baseUrl, token);
-      } catch (error) {
-        if (error instanceof Error && error.message.includes("Token already exists")) {
-          this._log(
-            "DEBUG",
-            `[CashuSpender] _spendInternal: Token already exists for ${baseUrl}, receiving newly created token and using existing`
-          );
-          const receiveResult = await this.receiveToken(token);
-          if (receiveResult.success) {
-            this._log(
-              "DEBUG",
-              `[CashuSpender] _spendInternal: Token restored successfully, amount=${receiveResult.amount}`
-            );
-          }
-          token = this.storageAdapter.getToken(baseUrl);
-        } else {
-          throw error;
-        }
-      }
+    if (token) {
+      this._log(
+        "DEBUG",
+        `[CashuSpender] _spendInternal: Successfully spent ${spentAmount}, returning token with balance=${spentAmount}`
+      );
     }
     this._logTransaction("spend", {
       amount: spentAmount,
@@ -1056,19 +1027,19 @@ var CashuSpender = class {
     };
   }
   /**
-   * Try to reuse an existing token
+   * Try to reuse an existing API key
    */
   async _tryReuseToken(baseUrl, amount, mintUrl) {
-    const storedToken = this.storageAdapter.getToken(baseUrl);
-    if (!storedToken) return null;
-    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
-    const balanceForBaseUrl = pendingDistribution.find((b) => b.baseUrl === baseUrl)?.amount || 0;
-    this._log("DEBUG", "RESUINGDSR GSODGNSD", balanceForBaseUrl, amount);
+    const apiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
+    if (!apiKeyEntry) return null;
+    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+    const balanceForBaseUrl = apiKeyDistribution.find((b) => b.baseUrl === baseUrl)?.amount || 0;
+    this._log("DEBUG", "Reusing API key", balanceForBaseUrl, amount);
     if (balanceForBaseUrl > amount) {
       const units = this.walletAdapter.getMintUnits();
       const unit = units[mintUrl] || "sat";
       return {
-        token: storedToken,
+        token: apiKeyEntry.key,
         status: "success",
         balance: balanceForBaseUrl,
         unit
@@ -1079,7 +1050,8 @@ var CashuSpender = class {
       const topUpResult = await this.balanceManager.topUp({
         mintUrl,
         baseUrl,
-        amount: topUpAmount
+        amount: topUpAmount,
+        token: apiKeyEntry.key
       });
       this._log("DEBUG", "TOPUP ", topUpResult);
       if (topUpResult.success && topUpResult.toppedUpAmount) {
@@ -1093,7 +1065,7 @@ var CashuSpender = class {
           status: "success"
         });
         return {
-          token: storedToken,
+          token: apiKeyEntry.key,
           status: "success",
           balance: newBalance,
           unit
@@ -1101,84 +1073,131 @@ var CashuSpender = class {
       }
       const providerBalance = await this._getProviderTokenBalance(
         baseUrl,
-        storedToken
+        apiKeyEntry.key
       );
       this._log("DEBUG", providerBalance);
       if (providerBalance <= 0) {
-        this.storageAdapter.removeToken(baseUrl);
+        this.storageAdapter.removeApiKey(baseUrl);
       }
     }
     return null;
   }
   /**
-   * Refund specific providers without retrying spend
+   * Refund all xcashu tokens from storage by calling the provider's refund endpoint.
+   * The xcashu token acts as an API key to claim the refund, and the response contains
+   * the actual refunded Cashu token which is then received into the wallet.
+   * @param mintUrl - The mint URL for receiving tokens
+   * @param excludeBaseUrls - Base URLs to exclude from refund (optional)
+   * @returns Results for each xcashu token refund attempt
    */
-  async refundProviders(baseUrls, mintUrl, refundApiKeys = false, forceRefund) {
+  async refundXcashuTokens(mintUrl, excludeBaseUrls) {
     const results = [];
-    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
-    const toRefund = pendingDistribution.filter(
-      (p) => baseUrls.includes(p.baseUrl)
-    );
-    const refundResults = await Promise.allSettled(
-      toRefund.map(async (pending) => {
-        const token = this.storageAdapter.getToken(pending.baseUrl);
-        this._log("DEBUG", token, this.balanceManager);
-        if (!token || !this.balanceManager) {
-          return { baseUrl: pending.baseUrl, success: false };
-        }
-        const tokenBalance = await this.balanceManager.getTokenBalance(
-          token,
-          pending.baseUrl
-        );
-        if (tokenBalance.reserved > 0) {
-          return { baseUrl: pending.baseUrl, success: false };
-        }
-        const result = await this.balanceManager.refund({
-          mintUrl,
-          baseUrl: pending.baseUrl,
-          token
-        });
-        this._log("DEBUG", result);
-        if (result.success) {
-          this.storageAdapter.removeToken(pending.baseUrl);
-        }
-        return { baseUrl: pending.baseUrl, success: result.success };
-      })
-    );
-    results.push(
-      ...refundResults.map(
-        (r) => r.status === "fulfilled" ? r.value : { baseUrl: "", success: false }
-      )
-    );
-    if (refundApiKeys) {
-      const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
-      const apiKeysToRefund = apiKeyDistribution.filter(
-        (p) => baseUrls.includes(p.baseUrl)
-      );
-      for (const apiKeyEntry of apiKeysToRefund) {
-        const apiKeyEntryFull = this.storageAdapter.getApiKey(
-          apiKeyEntry.baseUrl
-        );
-        if (apiKeyEntryFull && this.balanceManager) {
-          const refundResult = await this.balanceManager.refundApiKey({
-            mintUrl,
-            baseUrl: apiKeyEntry.baseUrl,
-            apiKey: apiKeyEntryFull.key,
-            forceRefund
-          });
-          if (refundResult.success) {
-            this.storageAdapter.updateApiKeyBalance(apiKeyEntry.baseUrl, 0);
+    const xcashuTokens = this.storageAdapter.getXcashuTokens();
+    const excludedUrls = new Set(excludeBaseUrls || []);
+    for (const [baseUrl, tokens] of Object.entries(xcashuTokens)) {
+      if (excludedUrls.has(baseUrl)) continue;
+      for (const xcashuToken of tokens) {
+        try {
+          if (!this.balanceManager) {
+            throw new Error("BalanceManager not available for xcashu refund");
+          }
+          const fetchResult = await this.balanceManager.fetchRefundToken(
+            baseUrl,
+            xcashuToken.token,
+            true
+          );
+          if (!fetchResult.success || !fetchResult.token) {
+            throw new Error(
+              fetchResult.error || "Failed to fetch refund token from provider"
+            );
+          }
+          const receiveResult = await this.receiveToken(fetchResult.token);
+          if (receiveResult.success) {
+            this.storageAdapter.removeXcashuToken(baseUrl, xcashuToken.token);
+            results.push({
+              baseUrl,
+              token: xcashuToken.token,
+              success: true
+            });
+            this._log(
+              "DEBUG",
+              `[CashuSpender] refundXcashuTokens: Successfully refunded xcashu token for ${baseUrl}, amount=${receiveResult.amount}`
+            );
+          } else {
+            const currentTryCount = xcashuToken.tryCount ?? 0;
+            const newTryCount = currentTryCount + 1;
+            this.storageAdapter.updateXcashuTokenTryCount(
+              xcashuToken.token,
+              newTryCount
+            );
+            results.push({
+              baseUrl,
+              token: xcashuToken.token,
+              success: false,
+              error: receiveResult.message ?? "Refund failed"
+            });
+            this._log(
+              "DEBUG",
+              `[CashuSpender] refundXcashuTokens: Failed to receive refund token for ${baseUrl}, incremented tryCount to ${newTryCount}`
+            );
           }
+        } catch (error) {
+          const currentTryCount = xcashuToken.tryCount ?? 0;
+          const newTryCount = currentTryCount + 1;
+          this.storageAdapter.updateXcashuTokenTryCount(
+            xcashuToken.token,
+            newTryCount
+          );
+          const errorMessage = error instanceof Error ? error.message : String(error);
           results.push({
-            baseUrl: apiKeyEntry.baseUrl,
-            success: refundResult.success
+            baseUrl,
+            token: xcashuToken.token,
+            success: false,
+            error: errorMessage
           });
+          this._log(
+            "ERROR",
+            `[CashuSpender] refundXcashuTokens: Exception during refund for ${baseUrl}: ${errorMessage}, incremented tryCount to ${newTryCount}`
+          );
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Refund specific providers without retrying spend
+   */
+  async refundProviders(mintUrl, forceRefund) {
+    const results = [];
+    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+    for (const apiKeyEntry of apiKeyDistribution) {
+      const apiKeyEntryFull = this.storageAdapter.getApiKey(
+        apiKeyEntry.baseUrl
+      );
+      if (apiKeyEntryFull && this.balanceManager) {
+        const refundResult = await this.balanceManager.refundApiKey({
+          mintUrl,
+          baseUrl: apiKeyEntry.baseUrl,
+          apiKey: apiKeyEntryFull.key,
+          forceRefund
+        });
+        if (refundResult.success) {
+          this.storageAdapter.removeApiKey(apiKeyEntry.baseUrl);
         } else {
-          results.push({
-            baseUrl: apiKeyEntry.baseUrl,
-            success: false
-          });
+          this.storageAdapter.updateApiKeyBalance(
+            apiKeyEntry.baseUrl,
+            apiKeyEntry.amount
+          );
         }
+        results.push({
+          baseUrl: apiKeyEntry.baseUrl,
+          success: refundResult.success
+        });
+      } else {
+        results.push({
+          baseUrl: apiKeyEntry.baseUrl,
+          success: false
+        });
       }
     }
     return results;
@@ -1263,13 +1282,8 @@ var BalanceManager = class {
       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]) {
@@ -1284,57 +1298,6 @@ var BalanceManager = class {
       mintBalances: normalizedMintBalances
     };
   }
-  /**
-   * Unified refund - handles both NIP-60 and legacy wallet refunds
-   */
-  async refund(options) {
-    const { mintUrl, baseUrl, token: providedToken } = options;
-    const storedToken = providedToken || this.storageAdapter.getToken(baseUrl);
-    if (!storedToken) {
-      console.log("[BalanceManager] No token to refund, returning early");
-      return { success: true, message: "No API key to refund" };
-    }
-    let fetchResult;
-    try {
-      fetchResult = await this._fetchRefundToken(baseUrl, storedToken);
-      if (!fetchResult.success) {
-        return {
-          success: false,
-          message: fetchResult.error || "Refund failed",
-          requestId: fetchResult.requestId
-        };
-      }
-      if (!fetchResult.token) {
-        return {
-          success: false,
-          message: "No token received from refund",
-          requestId: fetchResult.requestId
-        };
-      }
-      if (fetchResult.error === "No balance to refund") {
-        console.log(
-          "[BalanceManager] No balance to refund, removing stored token"
-        );
-        this.storageAdapter.removeToken(baseUrl);
-        return { success: true, message: "No balance to refund" };
-      }
-      const receiveResult = await this.cashuSpender.receiveToken(
-        fetchResult.token
-      );
-      const totalAmountMsat = receiveResult.unit === "msat" ? receiveResult.amount : receiveResult.amount * 1e3;
-      if (!providedToken) {
-        this.storageAdapter.removeToken(baseUrl);
-      }
-      return {
-        success: receiveResult.success,
-        refundedAmount: totalAmountMsat,
-        requestId: fetchResult.requestId
-      };
-    } catch (error) {
-      console.error("[BalanceManager] Refund error", error);
-      return this._handleRefundError(error, mintUrl, fetchResult?.requestId);
-    }
-  }
   /**
    * Refund API key balance - convert remaining API key balance to cashu token
    * @param options - Refund options including forceRefund flag
@@ -1362,7 +1325,7 @@ var BalanceManager = class {
     }
     let fetchResult;
     try {
-      fetchResult = await this._fetchRefundTokenWithApiKey(baseUrl, apiKey);
+      fetchResult = await this.fetchRefundToken(baseUrl, apiKey);
       if (!fetchResult.success) {
         return {
           success: false,
@@ -1398,9 +1361,9 @@ var BalanceManager = class {
     }
   }
   /**
-   * Fetch refund token from provider API using API key authentication
+   * Fetch refund token from provider API using API key (or xcashu token) authentication
    */
-  async _fetchRefundTokenWithApiKey(baseUrl, apiKey) {
+  async fetchRefundToken(baseUrl, apiKeyOrToken, xCashu = false) {
     if (!baseUrl) {
       return {
         success: false,
@@ -1414,12 +1377,17 @@ var BalanceManager = class {
       controller.abort();
     }, 6e4);
     try {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (xCashu) {
+        headers["X-Cashu"] = apiKeyOrToken;
+      } else {
+        headers["Authorization"] = `Bearer ${apiKeyOrToken}`;
+      }
       const response = await fetch(url, {
         method: "POST",
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          "Content-Type": "application/json"
-        },
+        headers,
         signal: controller.signal
       });
       clearTimeout(timeoutId);
@@ -1440,10 +1408,7 @@ var BalanceManager = class {
       };
     } catch (error) {
       clearTimeout(timeoutId);
-      console.error(
-        "[BalanceManager._fetchRefundTokenWithApiKey] Fetch error",
-        error
-      );
+      console.error("[BalanceManager.fetchRefundToken] Fetch error", error);
       if (error instanceof Error) {
         if (error.name === "AbortError") {
           return {
@@ -1470,8 +1435,9 @@ var BalanceManager = class {
     if (!amount || amount <= 0) {
       return { success: false, message: "Invalid top up amount" };
     }
-    const storedToken = providedToken || this.storageAdapter.getToken(baseUrl);
-    if (!storedToken) {
+    const apiKeyEntry = providedToken ? null : this.storageAdapter.getApiKey(baseUrl);
+    const apiKey = providedToken || apiKeyEntry?.key;
+    if (!apiKey) {
       return { success: false, message: "No API key available for top up" };
     }
     let cashuToken = null;
@@ -1489,11 +1455,7 @@ var BalanceManager = class {
         };
       }
       cashuToken = tokenResult.token;
-      const topUpResult = await this._postTopUp(
-        baseUrl,
-        storedToken,
-        cashuToken
-      );
+      const topUpResult = await this._postTopUp(baseUrl, apiKey, cashuToken);
       requestId = topUpResult.requestId;
       console.log(topUpResult);
       if (!topUpResult.success) {
@@ -1706,38 +1668,11 @@ var BalanceManager = class {
     return candidates;
   }
   async _refundOtherProvidersForTopUp(baseUrl, mintUrl, retryCount) {
-    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
     const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
     const forceRefund = retryCount >= 2;
-    const toRefund = pendingDistribution.filter(
-      (pending) => pending.baseUrl !== baseUrl
-    );
     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) {
-          return { baseUrl: pending.baseUrl, success: false };
-        }
-        const tokenBalance = await this.getTokenBalance(token, pending.baseUrl);
-        if (tokenBalance.reserved > 0) {
-          return { baseUrl: pending.baseUrl, success: false };
-        }
-        const result = await this.refund({
-          mintUrl,
-          baseUrl: pending.baseUrl,
-          token
-        });
-        return { baseUrl: pending.baseUrl, success: result.success };
-      })
-    );
-    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(
@@ -1761,77 +1696,6 @@ var BalanceManager = class {
       }
     }
   }
-  /**
-   * Fetch refund token from provider API
-   */
-  async _fetchRefundToken(baseUrl, storedToken) {
-    if (!baseUrl) {
-      return {
-        success: false,
-        error: "No base URL configured"
-      };
-    }
-    const normalizedBaseUrl = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-    const url = `${normalizedBaseUrl}v1/wallet/refund`;
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => {
-      controller.abort();
-    }, 6e4);
-    try {
-      const response = await fetch(url, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${storedToken}`,
-          "Content-Type": "application/json"
-        },
-        signal: controller.signal
-      });
-      clearTimeout(timeoutId);
-      const requestId = response.headers.get("x-routstr-request-id") || void 0;
-      if (!response.ok) {
-        const errorData = await response.json().catch(() => ({}));
-        if (response.status === 400 && errorData?.detail === "No balance to refund") {
-          this.storageAdapter.removeToken(baseUrl);
-          return {
-            success: false,
-            requestId,
-            error: "No balance to refund"
-          };
-        }
-        return {
-          success: false,
-          requestId,
-          error: `Refund request failed with status ${response.status}: ${errorData?.detail || response.statusText}`
-        };
-      }
-      const data = await response.json();
-      console.log("refund rsule", data);
-      return {
-        success: true,
-        token: data.token,
-        requestId
-      };
-    } catch (error) {
-      clearTimeout(timeoutId);
-      console.error("[BalanceManager._fetchRefundToken] Fetch error", error);
-      if (error instanceof Error) {
-        if (error.name === "AbortError") {
-          return {
-            success: false,
-            error: "Request timed out after 1 minute"
-          };
-        }
-        return {
-          success: false,
-          error: error.message
-        };
-      }
-      return {
-        success: false,
-        error: "Unknown error occurred during refund request"
-      };
-    }
-  }
   /**
    * Post topup request to provider API
    */
@@ -1957,7 +1821,7 @@ var BalanceManager = class {
         console.log(response.status);
         const data = await response.json();
         console.log("FAILED ", data);
-        const isInvalidApiKey = response.status === 401 && data?.code === "invalid_api_key" && data?.message?.includes("proofs already spent");
+        const isInvalidApiKey = response.status === 401 && data?.detail?.error?.code === "invalid_api_key" && data?.detail?.error?.message?.includes("proofs already spent");
         return {
           amount: -1,
           reserved: data.reserved ?? 0,
@@ -2455,8 +2319,13 @@ function isInsecureHttpUrl(url) {
   return url.startsWith("http://");
 }
 var ProviderManager = class _ProviderManager {
-  constructor(providerRegistry) {
+  constructor(providerRegistry, store) {
     this.providerRegistry = providerRegistry;
+    this.instanceId = `pm_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    if (store) {
+      this.store = store;
+      this.hydrateFromStore();
+    }
   }
   failedProviders = /* @__PURE__ */ new Set();
   /** Track when each provider last failed (provider URL -> timestamp) */
@@ -2465,14 +2334,57 @@ var ProviderManager = class _ProviderManager {
   providersOnCoolDown = [];
   /** Cooldown duration in milliseconds (5 minutes) */
   static COOLDOWN_DURATION_MS = 5 * 60 * 1e3;
+  /** Optional persistent store for failure tracking */
+  store = null;
+  /** Instance ID for debugging */
+  instanceId;
+  /**
+   * Hydrate in-memory state from persistent store
+   */
+  hydrateFromStore() {
+    if (!this.store) return;
+    const state = this.store.getState();
+    this.failedProviders = new Set(state.failedProviders);
+    this.lastFailed = new Map(Object.entries(state.lastFailed));
+    const now = Date.now();
+    this.providersOnCoolDown = state.providersOnCooldown.filter(
+      (entry) => now - entry.timestamp < _ProviderManager.COOLDOWN_DURATION_MS
+    ).map((entry) => [entry.baseUrl, entry.timestamp]);
+    console.log(`[ProviderManager:${this.instanceId}] Hydrated from store:`);
+    console.log(`  failedProviders: ${this.failedProviders.size}`);
+    console.log(`  lastFailed: ${this.lastFailed.size}`);
+    console.log(`  providersOnCooldown: ${this.providersOnCoolDown.length}`);
+  }
+  /**
+   * Get instance ID for debugging
+   */
+  getInstanceId() {
+    return this.instanceId;
+  }
   /**
    * Clean up expired cooldown entries
    */
   cleanupExpiredCooldowns() {
     const now = Date.now();
+    const before = this.providersOnCoolDown.length;
     this.providersOnCoolDown = this.providersOnCoolDown.filter(
-      ([, timestamp]) => now - timestamp < _ProviderManager.COOLDOWN_DURATION_MS
+      ([url, timestamp]) => {
+        const age = now - timestamp;
+        const isExpired = age >= _ProviderManager.COOLDOWN_DURATION_MS;
+        if (isExpired) {
+          console.log(
+            `[cleanupExpiredCooldowns:${this.instanceId}] Removing expired cooldown for ${url} (age: ${age}ms, cooldown: ${_ProviderManager.COOLDOWN_DURATION_MS}ms)`
+          );
+        }
+        return !isExpired;
+      }
     );
+    const after = this.providersOnCoolDown.length;
+    if (before !== after) {
+      console.log(
+        `[cleanupExpiredCooldowns:${this.instanceId}] Cleaned up ${before - after} expired cooldown(s), ${after} remaining`
+      );
+    }
   }
   /**
    * Get the cooldown duration in milliseconds
@@ -2485,7 +2397,8 @@ var ProviderManager = class _ProviderManager {
    */
   isOnCooldown(baseUrl) {
     this.cleanupExpiredCooldowns();
-    return this.providersOnCoolDown.some(([url]) => url === baseUrl);
+    const result = this.providersOnCoolDown.some(([url]) => url === baseUrl);
+    return result;
   }
   /**
    * Get all providers currently on cooldown
@@ -2499,6 +2412,9 @@ var ProviderManager = class _ProviderManager {
    */
   resetFailedProviders() {
     this.failedProviders.clear();
+    if (this.store) {
+      this.store.getState().setFailedProviders([]);
+    }
   }
   /**
    * Get the last failed timestamp for a provider
@@ -2519,13 +2435,62 @@ var ProviderManager = class _ProviderManager {
   markFailed(baseUrl) {
     const now = Date.now();
     const lastFailure = this.lastFailed.get(baseUrl);
+    console.log(`[markFailed:${this.instanceId}] baseUrl: ${baseUrl}`);
+    console.log(
+      `[markFailed:${this.instanceId}] lastFailure from map: ${lastFailure}`
+    );
+    console.log(
+      `[markFailed:${this.instanceId}] current timestamp (now): ${now}`
+    );
+    console.log(
+      `[markFailed:${this.instanceId}] COOLDOWN_DURATION_MS: ${_ProviderManager.COOLDOWN_DURATION_MS}`
+    );
+    if (lastFailure !== void 0) {
+      const timeSinceLastFailure = now - lastFailure;
+      console.log(
+        `[markFailed:${this.instanceId}] timeSinceLastFailure: ${timeSinceLastFailure}ms`
+      );
+      console.log(
+        `[markFailed:${this.instanceId}] isWithinCooldownWindow: ${timeSinceLastFailure < _ProviderManager.COOLDOWN_DURATION_MS}`
+      );
+    }
     this.lastFailed.set(baseUrl, now);
     this.failedProviders.add(baseUrl);
+    if (this.store) {
+      this.store.getState().setLastFailedTimestamp(baseUrl, now);
+      this.store.getState().addFailedProvider(baseUrl);
+    }
+    console.log(
+      `[markFailed:${this.instanceId}] Updated lastFailed map for ${baseUrl} to ${now}`
+    );
+    console.log(
+      `[markFailed:${this.instanceId}] failedProviders set size: ${this.failedProviders.size}`
+    );
     if (lastFailure !== void 0 && now - lastFailure < _ProviderManager.COOLDOWN_DURATION_MS) {
+      console.log(
+        `[markFailed:${this.instanceId}] Second failure detected within cooldown window for ${baseUrl}`
+      );
       if (!this.isOnCooldown(baseUrl)) {
         this.providersOnCoolDown.push([baseUrl, now]);
+        if (this.store) {
+          this.store.getState().addProviderOnCooldown(baseUrl, now);
+        }
+        console.log(
+          `[markFailed:${this.instanceId}] Provider ${baseUrl} added to cooldown after second failure within 5 minutes`
+        );
+      } else {
+        console.log(
+          `[markFailed:${this.instanceId}] Provider ${baseUrl} is already on cooldown`
+        );
+      }
+    } else {
+      if (lastFailure === void 0) {
+        console.log(
+          `[markFailed:${this.instanceId}] First failure for ${baseUrl} - not adding to cooldown yet`
+        );
+      } else {
         console.log(
-          `Provider ${baseUrl} added to cooldown after second failure within 5 minutes`
+          `[markFailed:${this.instanceId}] Failure outside cooldown window for ${baseUrl} (timeSinceLastFailure: ${now - lastFailure}ms)`
         );
       }
     }
@@ -2537,18 +2502,27 @@ var ProviderManager = class _ProviderManager {
     this.providersOnCoolDown = this.providersOnCoolDown.filter(
       ([url]) => url !== baseUrl
     );
+    if (this.store) {
+      this.store.getState().removeProviderFromCooldown(baseUrl);
+    }
   }
   /**
    * Clear all cooldown tracking
    */
   clearCooldowns() {
     this.providersOnCoolDown = [];
+    if (this.store) {
+      this.store.getState().clearProvidersOnCooldown();
+    }
   }
   /**
    * Clear all failure tracking (lastFailed timestamps)
    */
   clearFailureHistory() {
     this.lastFailed.clear();
+    if (this.store) {
+      this.store.getState().setLastFailed({});
+    }
   }
   /**
    * Check if a provider has failed
@@ -2876,38 +2850,54 @@ var createMemoryDriver = (seed) => {
 var isBun = () => {
   return typeof process.versions.bun !== "undefined";
 };
-var createDatabase = (dbPath) => {
+var cachedDbModule = null;
+var loadDatabase = async (dbPath) => {
   if (isBun()) {
     throw new Error(
-      "SQLite driver not supported in Bun. Use createMemoryDriver() instead."
+      "SQLite driver not supported in Bun. Use createBunSqliteDriver() instead."
     );
   }
-  let Database = null;
   try {
-    Database = __require("better-sqlite3");
+    if (!cachedDbModule) {
+      cachedDbModule = (await import('better-sqlite3')).default;
+    }
+    return new cachedDbModule(dbPath);
   } catch (error) {
     throw new Error(
       `better-sqlite3 is required for sqlite storage. Install it to use sqlite storage. (${error})`
     );
   }
-  return new Database(dbPath);
 };
 var createSqliteDriver = (options = {}) => {
   const dbPath = options.dbPath || "routstr.sqlite";
   const tableName = options.tableName || "sdk_storage";
-  const db = createDatabase(dbPath);
-  db.exec(
-    `CREATE TABLE IF NOT EXISTS ${tableName} (key TEXT PRIMARY KEY, value TEXT NOT NULL)`
-  );
-  const selectStmt = db.prepare(`SELECT value FROM ${tableName} WHERE key = ?`);
-  const upsertStmt = db.prepare(
-    `INSERT INTO ${tableName} (key, value) VALUES (?, ?)
+  let db;
+  let selectStmt;
+  let upsertStmt;
+  let deleteStmt;
+  const initDb = async () => {
+    if (!db) {
+      db = await loadDatabase(dbPath);
+      db.exec(
+        `CREATE TABLE IF NOT EXISTS ${tableName} (key TEXT PRIMARY KEY, value TEXT NOT NULL)`
+      );
+      selectStmt = db.prepare(`SELECT value FROM ${tableName} WHERE key = ?`);
+      upsertStmt = db.prepare(
+        `INSERT INTO ${tableName} (key, value) VALUES (?, ?)
      ON CONFLICT(key) DO UPDATE SET value = excluded.value`
-  );
-  const deleteStmt = db.prepare(`DELETE FROM ${tableName} WHERE key = ?`);
+      );
+      deleteStmt = db.prepare(`DELETE FROM ${tableName} WHERE key = ?`);
+    }
+  };
+  const ensureInit = async () => {
+    if (!db) {
+      await initDb();
+    }
+  };
   return {
     async getItem(key, defaultValue) {
       try {
+        await ensureInit();
         const row = selectStmt.get(key);
         if (!row || typeof row.value !== "string") return defaultValue;
         try {
@@ -2925,6 +2915,7 @@ var createSqliteDriver = (options = {}) => {
     },
     async setItem(key, value) {
       try {
+        await ensureInit();
         upsertStmt.run(key, JSON.stringify(value));
       } catch (error) {
         console.error(`SQLite setItem failed for key "${key}":`, error);
@@ -2932,6 +2923,7 @@ var createSqliteDriver = (options = {}) => {
     },
     async removeItem(key) {
       try {
+        await ensureInit();
         deleteStmt.run(key);
       } catch (error) {
         console.error(`SQLite removeItem failed for key "${key}":`, error);
@@ -2939,6 +2931,54 @@ var createSqliteDriver = (options = {}) => {
     }
   };
 };
+async function createBunSqliteDriver(dbPath) {
+  const SQLite = (await import(
+    /* webpackIgnore: true */
+    'bun:sqlite'
+  )).default;
+  const db = new SQLite(dbPath);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS sdk_storage (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )
+  `);
+  return {
+    async getItem(key, defaultValue) {
+      try {
+        const row = db.query("SELECT value FROM sdk_storage WHERE key = ?").get(key);
+        if (!row || typeof row.value !== "string") return defaultValue;
+        try {
+          return JSON.parse(row.value);
+        } catch (parseError) {
+          if (typeof defaultValue === "string") {
+            return row.value;
+          }
+          throw parseError;
+        }
+      } catch (error) {
+        console.error(`SQLite getItem failed for key "${key}":`, error);
+        return defaultValue;
+      }
+    },
+    async setItem(key, value) {
+      try {
+        db.query(
+          "INSERT INTO sdk_storage (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+        ).run(key, JSON.stringify(value));
+      } catch (error) {
+        console.error(`SQLite setItem failed for key "${key}":`, error);
+      }
+    },
+    async removeItem(key) {
+      try {
+        db.query("DELETE FROM sdk_storage WHERE key = ?").run(key);
+      } catch (error) {
+        console.error(`SQLite removeItem failed for key "${key}":`, error);
+      }
+    }
+  };
+}
 
 // storage/drivers/indexedDB.ts
 var isBrowser = typeof indexedDB !== "undefined";
@@ -3044,14 +3084,17 @@ var SDK_STORAGE_KEYS = {
   INFO_FROM_ALL_PROVIDERS: "info_from_all_providers",
   LAST_MODELS_UPDATE: "lastModelsUpdate",
   LAST_BASE_URLS_UPDATE: "lastBaseUrlsUpdate",
-  LOCAL_CASHU_TOKENS: "local_cashu_tokens",
   API_KEYS: "api_keys",
   CHILD_KEYS: "child_keys",
+  XCASHU_TOKENS: "xcashu_tokens",
   ROUTSTR21_MODELS: "routstr21Models",
   LAST_ROUTSTR21_MODELS_UPDATE: "lastRoutstr21ModelsUpdate",
   CACHED_RECEIVE_TOKENS: "cached_receive_tokens",
   USAGE_TRACKING: "usage_tracking",
-  CLIENT_IDS: "client_ids"
+  CLIENT_IDS: "client_ids",
+  FAILED_PROVIDERS: "failed_providers",
+  LAST_FAILED: "last_failed",
+  PROVIDERS_ON_COOLDOWN: "providers_on_cooldown"
 };
 
 // storage/usageTracking/indexedDB.ts
@@ -3237,21 +3280,23 @@ var normalizeBaseUrl2 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUr
 var isBun2 = () => {
   return typeof process.versions.bun !== "undefined";
 };
-var createDatabase2 = (dbPath) => {
+var cachedDbModule2 = null;
+var loadDatabase2 = async (dbPath) => {
   if (isBun2()) {
     throw new Error(
       "SQLite driver not supported in Bun. Use createMemoryDriver() instead."
     );
   }
-  let Database = null;
   try {
-    Database = __require("better-sqlite3");
+    if (!cachedDbModule2) {
+      cachedDbModule2 = (await import('better-sqlite3')).default;
+    }
+    return new cachedDbModule2(dbPath);
   } catch (error) {
     throw new Error(
       `better-sqlite3 is required for sqlite usage tracking. Install it to use sqlite storage. (${error})`
     );
   }
-  return new Database(dbPath);
 };
 var buildWhereClause = (options = {}) => {
   const clauses = [];
@@ -3288,38 +3333,49 @@ var buildWhereClause = (options = {}) => {
 var createSqliteUsageTrackingDriver = (options = {}) => {
   const dbPath = options.dbPath || "routstr.sqlite";
   const tableName = options.tableName || "usage_tracking";
-  const db = createDatabase2(dbPath);
   const legacyStorageDriver = options.legacyStorageDriver;
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS ${tableName} (
-      id TEXT PRIMARY KEY,
-      timestamp INTEGER NOT NULL,
-      model_id TEXT NOT NULL,
-      base_url TEXT NOT NULL,
-      request_id TEXT NOT NULL,
-      cost REAL NOT NULL,
-      sats_cost REAL NOT NULL,
-      prompt_tokens INTEGER NOT NULL,
-      completion_tokens INTEGER NOT NULL,
-      total_tokens INTEGER NOT NULL,
-      client TEXT,
-      session_id TEXT,
-      tags TEXT
-    );
-    CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName}(timestamp);
-    CREATE INDEX IF NOT EXISTS idx_${tableName}_model_id ON ${tableName}(model_id);
-    CREATE INDEX IF NOT EXISTS idx_${tableName}_base_url ON ${tableName}(base_url);
-    CREATE INDEX IF NOT EXISTS idx_${tableName}_session_id ON ${tableName}(session_id);
-    CREATE INDEX IF NOT EXISTS idx_${tableName}_client ON ${tableName}(client);
-  `);
-  const insertStmt = db.prepare(`
-    INSERT OR REPLACE INTO ${tableName} (
-      id, timestamp, model_id, base_url, request_id,
-      cost, sats_cost, prompt_tokens, completion_tokens, total_tokens,
-      client, session_id, tags
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
+  let db;
+  let insertStmt;
   let migrationComplete = false;
+  const initDb = async () => {
+    if (!db) {
+      db = await loadDatabase2(dbPath);
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS ${tableName} (
+          id TEXT PRIMARY KEY,
+          timestamp INTEGER NOT NULL,
+          model_id TEXT NOT NULL,
+          base_url TEXT NOT NULL,
+          request_id TEXT NOT NULL,
+          cost REAL NOT NULL,
+          sats_cost REAL NOT NULL,
+          prompt_tokens INTEGER NOT NULL,
+          completion_tokens INTEGER NOT NULL,
+          total_tokens INTEGER NOT NULL,
+          client TEXT,
+          session_id TEXT,
+          tags TEXT
+        );
+        CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName}(timestamp);
+        CREATE INDEX IF NOT EXISTS idx_${tableName}_model_id ON ${tableName}(model_id);
+        CREATE INDEX IF NOT EXISTS idx_${tableName}_base_url ON ${tableName}(base_url);
+        CREATE INDEX IF NOT EXISTS idx_${tableName}_session_id ON ${tableName}(session_id);
+        CREATE INDEX IF NOT EXISTS idx_${tableName}_client ON ${tableName}(client);
+      `);
+      insertStmt = db.prepare(`
+        INSERT OR REPLACE INTO ${tableName} (
+          id, timestamp, model_id, base_url, request_id,
+          cost, sats_cost, prompt_tokens, completion_tokens, total_tokens,
+          client, session_id, tags
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+    }
+  };
+  const ensureInit = async () => {
+    if (!db) {
+      await initDb();
+    }
+  };
   const appendOne = (entry) => {
     insertStmt.run(
       entry.id,
@@ -3377,19 +3433,23 @@ var createSqliteUsageTrackingDriver = (options = {}) => {
   });
   return {
     async migrate() {
+      await ensureInit();
       await ensureMigrated();
     },
     async append(entry) {
+      await ensureInit();
       await ensureMigrated();
       appendOne(entry);
     },
     async appendMany(entries) {
+      await ensureInit();
       await ensureMigrated();
       for (const entry of entries) {
         appendOne(entry);
       }
     },
     async list(options2 = {}) {
+      await ensureInit();
       await ensureMigrated();
       const { sql, params } = buildWhereClause(options2);
       const limitSql = typeof options2.limit === "number" ? " LIMIT ?" : "";
@@ -3402,6 +3462,7 @@ var createSqliteUsageTrackingDriver = (options = {}) => {
       return rows.map(mapRow);
     },
     async count(options2 = {}) {
+      await ensureInit();
       await ensureMigrated();
       const { sql, params } = buildWhereClause(options2);
       const stmt = db.prepare(`SELECT COUNT(*) as count FROM ${tableName} ${sql}`);
@@ -3409,20 +3470,197 @@ var createSqliteUsageTrackingDriver = (options = {}) => {
       return Number(row?.count ?? 0);
     },
     async deleteOlderThan(timestamp) {
+      await ensureInit();
       await ensureMigrated();
       const stmt = db.prepare(`DELETE FROM ${tableName} WHERE timestamp < ?`);
       const result = stmt.run(timestamp);
       return result.changes;
     },
     async clear() {
+      await ensureInit();
       await ensureMigrated();
       db.prepare(`DELETE FROM ${tableName}`).run();
     }
   };
 };
 
-// storage/usageTracking/memory.ts
+// storage/usageTracking/bunSqlite.ts
+var MIGRATION_MARKER_KEY3 = "usage_tracking_migration_v1";
 var normalizeBaseUrl3 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var buildWhereClause2 = (options = {}) => {
+  const clauses = [];
+  const params = [];
+  if (typeof options.before === "number") {
+    clauses.push("timestamp < ?");
+    params.push(options.before);
+  }
+  if (typeof options.after === "number") {
+    clauses.push("timestamp > ?");
+    params.push(options.after);
+  }
+  if (options.modelId) {
+    clauses.push("model_id = ?");
+    params.push(options.modelId);
+  }
+  if (options.baseUrl) {
+    clauses.push("base_url = ?");
+    params.push(normalizeBaseUrl3(options.baseUrl));
+  }
+  if (options.sessionId) {
+    clauses.push("session_id = ?");
+    params.push(options.sessionId);
+  }
+  if (options.client) {
+    clauses.push("client = ?");
+    params.push(options.client);
+  }
+  return {
+    sql: clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "",
+    params
+  };
+};
+var createBunSqliteUsageTrackingDriver = (options = {}) => {
+  const dbPath = options.dbPath || "routstr.sqlite";
+  const tableName = options.tableName || "usage_tracking";
+  const legacyStorageDriver = options.legacyStorageDriver;
+  const SQLiteDatabase = options.sqlite?.Database;
+  let migrationPromise = null;
+  if (!SQLiteDatabase) {
+    throw new Error(
+      "Bun SQLite Database constructor is required. Pass { sqlite: { Database } } when creating the driver."
+    );
+  }
+  const db = new SQLiteDatabase(dbPath);
+  db.run(`
+    CREATE TABLE IF NOT EXISTS ${tableName} (
+      id TEXT PRIMARY KEY,
+      timestamp INTEGER NOT NULL,
+      model_id TEXT NOT NULL,
+      base_url TEXT NOT NULL,
+      request_id TEXT NOT NULL,
+      cost REAL NOT NULL,
+      sats_cost REAL NOT NULL,
+      prompt_tokens INTEGER NOT NULL,
+      completion_tokens INTEGER NOT NULL,
+      total_tokens INTEGER NOT NULL,
+      client TEXT,
+      session_id TEXT,
+      tags TEXT
+    )
+  `);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName}(timestamp)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_model_id ON ${tableName}(model_id)`);
+  db.run(`CREATE INDEX IF NOT EXISTS idx_${tableName}_base_url ON ${tableName}(base_url)`);
+  const appendOne = (entry) => {
+    db.query(`
+      INSERT OR REPLACE INTO ${tableName} (
+        id, timestamp, model_id, base_url, request_id,
+        cost, sats_cost, prompt_tokens, completion_tokens, total_tokens,
+        client, session_id, tags
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(
+      entry.id,
+      entry.timestamp,
+      entry.modelId,
+      normalizeBaseUrl3(entry.baseUrl),
+      entry.requestId,
+      entry.cost,
+      entry.satsCost,
+      entry.promptTokens,
+      entry.completionTokens,
+      entry.totalTokens,
+      entry.client ?? null,
+      entry.sessionId ?? null,
+      JSON.stringify(entry.tags ?? [])
+    );
+  };
+  const mapRow = (row) => ({
+    id: row.id,
+    timestamp: row.timestamp,
+    modelId: row.model_id,
+    baseUrl: row.base_url,
+    requestId: row.request_id,
+    cost: row.cost,
+    satsCost: row.sats_cost,
+    promptTokens: row.prompt_tokens,
+    completionTokens: row.completion_tokens,
+    totalTokens: row.total_tokens,
+    client: row.client ?? void 0,
+    sessionId: row.session_id ?? void 0,
+    tags: typeof row.tags === "string" ? JSON.parse(row.tags) : void 0
+  });
+  const ensureMigrated = async () => {
+    if (!legacyStorageDriver) return;
+    if (!migrationPromise) {
+      migrationPromise = (async () => {
+        const migrated = await legacyStorageDriver.getItem(
+          MIGRATION_MARKER_KEY3,
+          false
+        );
+        if (migrated) return;
+        const legacyEntries = await legacyStorageDriver.getItem(
+          SDK_STORAGE_KEYS.USAGE_TRACKING,
+          []
+        );
+        if (legacyEntries.length > 0) {
+          for (const entry of legacyEntries) {
+            appendOne(entry);
+          }
+          await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
+        }
+        await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY3, true);
+      })();
+    }
+    await migrationPromise;
+  };
+  return {
+    async migrate() {
+      await ensureMigrated();
+    },
+    async append(entry) {
+      await ensureMigrated();
+      appendOne(entry);
+    },
+    async appendMany(entries) {
+      await ensureMigrated();
+      for (const entry of entries) {
+        appendOne(entry);
+      }
+    },
+    async list(options2 = {}) {
+      await ensureMigrated();
+      const { sql, params } = buildWhereClause2(options2);
+      const limitSql = typeof options2.limit === "number" ? " LIMIT ?" : "";
+      const query = `SELECT * FROM ${tableName} ${sql} ORDER BY timestamp DESC${limitSql}`;
+      let rows;
+      if (typeof options2.limit === "number") {
+        rows = db.query(query).all(...params, options2.limit);
+      } else {
+        rows = db.query(query).all(...params);
+      }
+      return rows.map(mapRow);
+    },
+    async count(options2 = {}) {
+      const { sql, params } = buildWhereClause2(options2);
+      const query = `SELECT COUNT(*) as count FROM ${tableName} ${sql}`;
+      const row = db.query(query).get(...params);
+      return Number(row?.count ?? 0);
+    },
+    async deleteOlderThan(timestamp) {
+      await ensureMigrated();
+      const before = timestamp;
+      const result = db.query(`DELETE FROM ${tableName} WHERE timestamp < ?`).run(before);
+      return result.changes ?? 0;
+    },
+    async clear() {
+      await ensureMigrated();
+      db.query(`DELETE FROM ${tableName}`).run();
+    }
+  };
+};
+
+// storage/usageTracking/memory.ts
+var normalizeBaseUrl4 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
 var matchesFilters2 = (entry, options = {}) => {
   if (typeof options.before === "number" && entry.timestamp >= options.before) {
     return false;
@@ -3433,7 +3671,7 @@ var matchesFilters2 = (entry, options = {}) => {
   if (options.modelId && entry.modelId !== options.modelId) {
     return false;
   }
-  if (options.baseUrl && normalizeBaseUrl3(entry.baseUrl) !== normalizeBaseUrl3(options.baseUrl)) {
+  if (options.baseUrl && normalizeBaseUrl4(entry.baseUrl) !== normalizeBaseUrl4(options.baseUrl)) {
     return false;
   }
   if (options.sessionId && entry.sessionId !== options.sessionId) {
@@ -3447,18 +3685,18 @@ var matchesFilters2 = (entry, options = {}) => {
 var createMemoryUsageTrackingDriver = (seed = []) => {
   const store = /* @__PURE__ */ new Map();
   for (const entry of seed) {
-    store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl3(entry.baseUrl) });
+    store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
   }
   return {
     async migrate() {
       return;
     },
     async append(entry) {
-      store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl3(entry.baseUrl) });
+      store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
     },
     async appendMany(entries) {
       for (const entry of entries) {
-        store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl3(entry.baseUrl) });
+        store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
       }
     },
     async list(options = {}) {
@@ -3486,20 +3724,7 @@ var createMemoryUsageTrackingDriver = (seed = []) => {
     }
   };
 };
-var normalizeBaseUrl4 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var getCashuTokenBalance = (token) => {
-  try {
-    const decoded = cashuTs.getDecodedToken(token);
-    const unitDivisor = decoded.unit === "msat" ? 1e3 : 1;
-    let sum = 0;
-    for (const proof of decoded.proofs) {
-      sum += proof.amount / unitDivisor;
-    }
-    return sum;
-  } catch {
-    return 0;
-  }
-};
+var normalizeBaseUrl5 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
 var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   modelsFromAllProviders: {},
   lastUsedModel: null,
@@ -3509,17 +3734,20 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   mintsFromAllProviders: {},
   infoFromAllProviders: {},
   lastModelsUpdate: {},
-  cachedTokens: [],
   apiKeys: [],
   childKeys: [],
+  xcashuTokens: {},
   routstr21Models: [],
   lastRoutstr21ModelsUpdate: null,
   cachedReceiveTokens: [],
   clientIds: [],
+  failedProviders: [],
+  lastFailed: {},
+  providersOnCooldown: [],
   setModelsFromAllProviders: (value) => {
     const normalized = {};
     for (const [baseUrl, models] of Object.entries(value)) {
-      normalized[normalizeBaseUrl4(baseUrl)] = models;
+      normalized[normalizeBaseUrl5(baseUrl)] = models;
     }
     void driver.setItem(
       SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
@@ -3532,7 +3760,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     set({ lastUsedModel: value });
   },
   setBaseUrlsList: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl4(url));
+    const normalized = value.map((url) => normalizeBaseUrl5(url));
     void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
     set({ baseUrlsList: normalized });
   },
@@ -3541,14 +3769,14 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     set({ lastBaseUrlsUpdate: value });
   },
   setDisabledProviders: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl4(url));
+    const normalized = value.map((url) => normalizeBaseUrl5(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[normalizeBaseUrl4(baseUrl)] = mints.map(
+      normalized[normalizeBaseUrl5(baseUrl)] = mints.map(
         (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
       );
     }
@@ -3561,7 +3789,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   setInfoFromAllProviders: (value) => {
     const normalized = {};
     for (const [baseUrl, info] of Object.entries(value)) {
-      normalized[normalizeBaseUrl4(baseUrl)] = info;
+      normalized[normalizeBaseUrl5(baseUrl)] = info;
     }
     void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
     set({ infoFromAllProviders: normalized });
@@ -3569,30 +3797,17 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   setLastModelsUpdate: (value) => {
     const normalized = {};
     for (const [baseUrl, timestamp] of Object.entries(value)) {
-      normalized[normalizeBaseUrl4(baseUrl)] = timestamp;
+      normalized[normalizeBaseUrl5(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: normalizeBaseUrl4(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: normalizeBaseUrl4(entry.baseUrl),
+        baseUrl: normalizeBaseUrl5(entry.baseUrl),
         balance: entry.balance ?? 0,
         lastUsed: entry.lastUsed ?? null
       }));
@@ -3604,7 +3819,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     set((state) => {
       const updates = typeof value === "function" ? value(state.childKeys) : value;
       const normalized = updates.map((entry) => ({
-        parentBaseUrl: normalizeBaseUrl4(entry.parentBaseUrl),
+        parentBaseUrl: normalizeBaseUrl5(entry.parentBaseUrl),
         childKey: entry.childKey,
         balance: entry.balance ?? 0,
         balanceLimit: entry.balanceLimit,
@@ -3615,6 +3830,30 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
       return { childKeys: normalized };
     });
   },
+  setXcashuTokens: (value) => {
+    const normalized = {};
+    for (const [baseUrl, tokens] of Object.entries(value)) {
+      normalized[normalizeBaseUrl5(baseUrl)] = tokens.map((entry) => ({
+        ...entry,
+        baseUrl: normalizeBaseUrl5(entry.baseUrl),
+        createdAt: entry.createdAt ?? Date.now(),
+        tryCount: entry.tryCount ?? 0
+      }));
+    }
+    void driver.setItem(SDK_STORAGE_KEYS.XCASHU_TOKENS, normalized);
+    set({ xcashuTokens: normalized });
+  },
+  updateXcashuTokenTryCount: (token, tryCount) => {
+    const currentTokens = get().xcashuTokens;
+    const updatedTokens = {};
+    for (const [baseUrl, tokens] of Object.entries(currentTokens)) {
+      updatedTokens[baseUrl] = tokens.map(
+        (entry) => entry.token === token ? { ...entry, tryCount } : entry
+      );
+    }
+    void driver.setItem(SDK_STORAGE_KEYS.XCASHU_TOKENS, updatedTokens);
+    set({ xcashuTokens: updatedTokens });
+  },
   setRoutstr21Models: (value) => {
     void driver.setItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, value);
     set({ routstr21Models: value });
@@ -3644,6 +3883,71 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
       void driver.setItem(SDK_STORAGE_KEYS.CLIENT_IDS, normalized);
       return { clientIds: normalized };
     });
+  },
+  // ========== Failure Tracking ==========
+  setFailedProviders: (value) => {
+    const normalized = value.map((url) => normalizeBaseUrl5(url));
+    void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, normalized);
+    set({ failedProviders: normalized });
+  },
+  addFailedProvider: (baseUrl) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().failedProviders;
+    if (!current.includes(normalized)) {
+      const updated = [...current, normalized];
+      void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, updated);
+      set({ failedProviders: updated });
+    }
+  },
+  removeFailedProvider: (baseUrl) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().failedProviders;
+    const updated = current.filter((url) => url !== normalized);
+    void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, updated);
+    set({ failedProviders: updated });
+  },
+  setLastFailed: (value) => {
+    const normalized = {};
+    for (const [baseUrl, timestamp] of Object.entries(value)) {
+      normalized[normalizeBaseUrl5(baseUrl)] = timestamp;
+    }
+    void driver.setItem(SDK_STORAGE_KEYS.LAST_FAILED, normalized);
+    set({ lastFailed: normalized });
+  },
+  setLastFailedTimestamp: (baseUrl, timestamp) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().lastFailed;
+    const updated = { ...current, [normalized]: timestamp };
+    void driver.setItem(SDK_STORAGE_KEYS.LAST_FAILED, updated);
+    set({ lastFailed: updated });
+  },
+  setProvidersOnCooldown: (value) => {
+    const normalized = value.map((entry) => ({
+      baseUrl: normalizeBaseUrl5(entry.baseUrl),
+      timestamp: entry.timestamp
+    }));
+    void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, normalized);
+    set({ providersOnCooldown: normalized });
+  },
+  addProviderOnCooldown: (baseUrl, timestamp) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().providersOnCooldown;
+    if (!current.some((entry) => entry.baseUrl === normalized)) {
+      const updated = [...current, { baseUrl: normalized, timestamp }];
+      void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, updated);
+      set({ providersOnCooldown: updated });
+    }
+  },
+  removeProviderFromCooldown: (baseUrl) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().providersOnCooldown;
+    const updated = current.filter((entry) => entry.baseUrl !== normalized);
+    void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, updated);
+    set({ providersOnCooldown: updated });
+  },
+  clearProvidersOnCooldown: () => {
+    void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, []);
+    set({ providersOnCooldown: [] });
   }
 }));
 var hydrateStoreFromDriver = async (store, driver) => {
@@ -3656,13 +3960,16 @@ var hydrateStoreFromDriver = async (store, driver) => {
     rawMints,
     rawInfo,
     rawLastModelsUpdate,
-    rawCachedTokens,
     rawApiKeys,
     rawChildKeys,
+    rawXcashuTokens,
     rawRoutstr21Models,
     rawLastRoutstr21ModelsUpdate,
     rawCachedReceiveTokens,
-    rawClientIds
+    rawClientIds,
+    rawFailedProviders,
+    rawLastFailed,
+    rawProvidersOnCooldown
   ] = await Promise.all([
     driver.getItem(
       SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
@@ -3684,65 +3991,73 @@ var hydrateStoreFromDriver = async (store, driver) => {
       SDK_STORAGE_KEYS.LAST_MODELS_UPDATE,
       {}
     ),
-    driver.getItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, []),
     driver.getItem(SDK_STORAGE_KEYS.API_KEYS, []),
     driver.getItem(SDK_STORAGE_KEYS.CHILD_KEYS, []),
+    driver.getItem(SDK_STORAGE_KEYS.XCASHU_TOKENS, {}),
     driver.getItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, []),
     driver.getItem(
       SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE,
       null
     ),
     driver.getItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, []),
-    driver.getItem(SDK_STORAGE_KEYS.CLIENT_IDS, [])
+    driver.getItem(SDK_STORAGE_KEYS.CLIENT_IDS, []),
+    driver.getItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, []),
+    driver.getItem(SDK_STORAGE_KEYS.LAST_FAILED, {}),
+    driver.getItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, [])
   ]);
   const modelsFromAllProviders = Object.fromEntries(
     Object.entries(rawModels).map(([baseUrl, models]) => [
-      normalizeBaseUrl4(baseUrl),
+      normalizeBaseUrl5(baseUrl),
       models
     ])
   );
-  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl4(url));
+  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl5(url));
   const disabledProviders = rawDisabledProviders.map(
-    (url) => normalizeBaseUrl4(url)
+    (url) => normalizeBaseUrl5(url)
   );
   const mintsFromAllProviders = Object.fromEntries(
     Object.entries(rawMints).map(([baseUrl, mints]) => [
-      normalizeBaseUrl4(baseUrl),
+      normalizeBaseUrl5(baseUrl),
       mints.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
     ])
   );
   const infoFromAllProviders = Object.fromEntries(
     Object.entries(rawInfo).map(([baseUrl, info]) => [
-      normalizeBaseUrl4(baseUrl),
+      normalizeBaseUrl5(baseUrl),
       info
     ])
   );
   const lastModelsUpdate = Object.fromEntries(
     Object.entries(rawLastModelsUpdate).map(([baseUrl, timestamp]) => [
-      normalizeBaseUrl4(baseUrl),
+      normalizeBaseUrl5(baseUrl),
       timestamp
     ])
   );
-  const cachedTokens = rawCachedTokens.map((entry) => ({
-    ...entry,
-    baseUrl: normalizeBaseUrl4(entry.baseUrl),
-    balance: typeof entry.balance === "number" ? entry.balance : getCashuTokenBalance(entry.token),
-    lastUsed: entry.lastUsed ?? null
-  }));
   const apiKeys = rawApiKeys.map((entry) => ({
     ...entry,
-    baseUrl: normalizeBaseUrl4(entry.baseUrl),
+    baseUrl: normalizeBaseUrl5(entry.baseUrl),
     balance: entry.balance ?? 0,
     lastUsed: entry.lastUsed ?? null
   }));
   const childKeys = rawChildKeys.map((entry) => ({
-    parentBaseUrl: normalizeBaseUrl4(entry.parentBaseUrl),
+    parentBaseUrl: normalizeBaseUrl5(entry.parentBaseUrl),
     childKey: entry.childKey,
     balance: entry.balance ?? 0,
     balanceLimit: entry.balanceLimit,
     validityDate: entry.validityDate,
     createdAt: entry.createdAt ?? Date.now()
   }));
+  const xcashuTokens = Object.fromEntries(
+    Object.entries(rawXcashuTokens).map(([baseUrl, tokens]) => [
+      normalizeBaseUrl5(baseUrl),
+      tokens.map((entry) => ({
+        baseUrl: normalizeBaseUrl5(entry.baseUrl),
+        token: entry.token,
+        createdAt: entry.createdAt ?? Date.now(),
+        tryCount: entry.tryCount ?? 0
+      }))
+    ])
+  );
   const routstr21Models = rawRoutstr21Models;
   const lastRoutstr21ModelsUpdate = rawLastRoutstr21ModelsUpdate;
   const cachedReceiveTokens = rawCachedReceiveTokens?.map((entry) => ({
@@ -3756,6 +4071,17 @@ var hydrateStoreFromDriver = async (store, driver) => {
     createdAt: entry.createdAt ?? Date.now(),
     lastUsed: entry.lastUsed ?? null
   }));
+  const failedProviders = rawFailedProviders.map((url) => normalizeBaseUrl5(url));
+  const lastFailed = Object.fromEntries(
+    Object.entries(rawLastFailed).map(([baseUrl, timestamp]) => [
+      normalizeBaseUrl5(baseUrl),
+      timestamp
+    ])
+  );
+  const providersOnCooldown = rawProvidersOnCooldown.map((entry) => ({
+    baseUrl: normalizeBaseUrl5(entry.baseUrl),
+    timestamp: entry.timestamp
+  }));
   store.setState({
     modelsFromAllProviders,
     lastUsedModel,
@@ -3765,13 +4091,16 @@ var hydrateStoreFromDriver = async (store, driver) => {
     mintsFromAllProviders,
     infoFromAllProviders,
     lastModelsUpdate,
-    cachedTokens,
     apiKeys,
     childKeys,
+    xcashuTokens,
     routstr21Models,
     lastRoutstr21ModelsUpdate,
     cachedReceiveTokens,
-    clientIds
+    clientIds,
+    failedProviders,
+    lastFailed,
+    providersOnCooldown
   });
 };
 var createSdkStore = ({
@@ -3791,12 +4120,12 @@ var createDiscoveryAdapterFromStore = (store) => ({
   getCachedProviderInfo: () => store.getState().infoFromAllProviders,
   setCachedProviderInfo: (info) => store.getState().setInfoFromAllProviders(info),
   getProviderLastUpdate: (baseUrl) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const timestamps = store.getState().lastModelsUpdate;
     return timestamps[normalized] || null;
   },
   setProviderLastUpdate: (baseUrl, timestamp) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const timestamps = { ...store.getState().lastModelsUpdate };
     timestamps[normalized] = timestamp;
     store.getState().setLastModelsUpdate(timestamps);
@@ -3814,59 +4143,6 @@ var createDiscoveryAdapterFromStore = (store) => ({
   setRoutstr21ModelsLastUpdate: (timestamp) => store.getState().setRoutstr21ModelsLastUpdate(timestamp)
 });
 var createStorageAdapterFromStore = (store) => ({
-  getToken: (baseUrl) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
-    const entry = store.getState().cachedTokens.find((token) => token.baseUrl === normalized);
-    if (!entry) return null;
-    const next = store.getState().cachedTokens.map(
-      (token) => token.baseUrl === normalized ? { ...token, lastUsed: Date.now() } : token
-    );
-    store.getState().setCachedTokens(next);
-    return entry.token;
-  },
-  setToken: (baseUrl, token) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
-    const tokens = store.getState().cachedTokens;
-    const balance = getCashuTokenBalance(token);
-    const existingIndex = tokens.findIndex(
-      (entry) => entry.baseUrl === normalized
-    );
-    if (existingIndex !== -1) {
-      throw new Error(`Token already exists for baseUrl: ${normalized}`);
-    }
-    const next = [...tokens];
-    next.push({
-      baseUrl: normalized,
-      token,
-      balance,
-      lastUsed: Date.now()
-    });
-    store.getState().setCachedTokens(next);
-  },
-  removeToken: (baseUrl) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
-    const next = store.getState().cachedTokens.filter((entry) => entry.baseUrl !== normalized);
-    store.getState().setCachedTokens(next);
-  },
-  updateTokenBalance: (baseUrl, balance) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
-    const tokens = store.getState().cachedTokens;
-    const next = tokens.map(
-      (entry) => entry.baseUrl === normalized ? { ...entry, balance } : entry
-    );
-    store.getState().setCachedTokens(next);
-  },
-  getCachedTokenDistribution: () => {
-    const cachedTokens = store.getState().cachedTokens;
-    const distributionMap = {};
-    for (const entry of cachedTokens) {
-      const sum = entry.balance || 0;
-      if (sum > 0) {
-        distributionMap[entry.baseUrl] = (distributionMap[entry.baseUrl] || 0) + sum;
-      }
-    }
-    return Object.entries(distributionMap).map(([baseUrl, amt]) => ({ baseUrl, amount: amt })).sort((a, b) => b.amount - a.amount);
-  },
   getApiKeyDistribution: () => {
     const apiKeys = store.getState().apiKeys;
     const distributionMap = {};
@@ -3879,28 +4155,24 @@ var createStorageAdapterFromStore = (store) => ({
     return Object.entries(distributionMap).map(([baseUrl, amt]) => ({ baseUrl, amount: amt })).sort((a, b) => b.amount - a.amount);
   },
   saveProviderInfo: (baseUrl, info) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const next = { ...store.getState().infoFromAllProviders };
     next[normalized] = info;
     store.getState().setInfoFromAllProviders(next);
   },
   getProviderInfo: (baseUrl) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     return store.getState().infoFromAllProviders[normalized] || null;
   },
   // ========== API Keys (for apikeys mode) ==========
   getApiKey: (baseUrl) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const entry = store.getState().apiKeys.find((key) => key.baseUrl === normalized);
     if (!entry) return null;
-    const next = store.getState().apiKeys.map(
-      (key) => key.baseUrl === normalized ? { ...key, lastUsed: Date.now() } : key
-    );
-    store.getState().setApiKeys(next);
     return entry;
   },
   setApiKey: (baseUrl, key) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const keys = store.getState().apiKeys;
     const existingIndex = keys.findIndex(
       (entry) => entry.baseUrl === normalized
@@ -3918,15 +4190,15 @@ var createStorageAdapterFromStore = (store) => ({
     store.getState().setApiKeys(next);
   },
   updateApiKeyBalance: (baseUrl, balance) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const keys = store.getState().apiKeys;
     const next = keys.map(
-      (entry) => entry.baseUrl === normalized ? { ...entry, balance } : entry
+      (entry) => entry.baseUrl === normalized ? { ...entry, balance, lastUsed: Date.now() } : entry
     );
     store.getState().setApiKeys(next);
   },
   removeApiKey: (baseUrl) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const next = store.getState().apiKeys.filter((entry) => entry.baseUrl !== normalized);
     store.getState().setApiKeys(next);
   },
@@ -3940,7 +4212,7 @@ var createStorageAdapterFromStore = (store) => ({
   },
   // ========== Child Keys ==========
   getChildKey: (parentBaseUrl) => {
-    const normalized = normalizeBaseUrl4(parentBaseUrl);
+    const normalized = normalizeBaseUrl5(parentBaseUrl);
     const entry = store.getState().childKeys.find((key) => key.parentBaseUrl === normalized);
     if (!entry) return null;
     return {
@@ -3953,7 +4225,7 @@ var createStorageAdapterFromStore = (store) => ({
     };
   },
   setChildKey: (parentBaseUrl, childKey, balance, validityDate, balanceLimit) => {
-    const normalized = normalizeBaseUrl4(parentBaseUrl);
+    const normalized = normalizeBaseUrl5(parentBaseUrl);
     const keys = store.getState().childKeys;
     const existingIndex = keys.findIndex(
       (entry) => entry.parentBaseUrl === normalized
@@ -3984,7 +4256,7 @@ var createStorageAdapterFromStore = (store) => ({
     }
   },
   updateChildKeyBalance: (parentBaseUrl, balance) => {
-    const normalized = normalizeBaseUrl4(parentBaseUrl);
+    const normalized = normalizeBaseUrl5(parentBaseUrl);
     const keys = store.getState().childKeys;
     const next = keys.map(
       (entry) => entry.parentBaseUrl === normalized ? { ...entry, balance } : entry
@@ -3992,7 +4264,7 @@ var createStorageAdapterFromStore = (store) => ({
     store.getState().setChildKeys(next);
   },
   removeChildKey: (parentBaseUrl) => {
-    const normalized = normalizeBaseUrl4(parentBaseUrl);
+    const normalized = normalizeBaseUrl5(parentBaseUrl);
     const next = store.getState().childKeys.filter((entry) => entry.parentBaseUrl !== normalized);
     store.getState().setChildKeys(next);
   },
@@ -4011,20 +4283,60 @@ var createStorageAdapterFromStore = (store) => ({
   },
   setCachedReceiveTokens: (tokens) => {
     store.getState().setCachedReceiveTokens(tokens);
+  },
+  // ========== XCashu Tokens (multiple tokens per baseUrl) ==========
+  getXcashuTokens: () => {
+    return store.getState().xcashuTokens;
+  },
+  getXcashuTokensForBaseUrl: (baseUrl) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    return store.getState().xcashuTokens[normalized] || [];
+  },
+  addXcashuToken: (baseUrl, token) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const tokens = store.getState().xcashuTokens;
+    const existing = tokens[normalized] || [];
+    const next = { ...tokens };
+    next[normalized] = [
+      ...existing,
+      { baseUrl: normalized, token, createdAt: Date.now(), tryCount: 0 }
+    ];
+    store.getState().setXcashuTokens(next);
+  },
+  removeXcashuToken: (baseUrl, token) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const tokens = store.getState().xcashuTokens;
+    const existing = tokens[normalized] || [];
+    const next = { ...tokens };
+    next[normalized] = existing.filter((entry) => entry.token !== token);
+    if (next[normalized].length === 0) {
+      delete next[normalized];
+    }
+    store.getState().setXcashuTokens(next);
+  },
+  clearXcashuTokensForBaseUrl: (baseUrl) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const tokens = store.getState().xcashuTokens;
+    const next = { ...tokens };
+    delete next[normalized];
+    store.getState().setXcashuTokens(next);
+  },
+  updateXcashuTokenTryCount: (token, tryCount) => {
+    store.getState().updateXcashuTokenTryCount(token, tryCount);
   }
 });
 var createProviderRegistryFromStore = (store) => ({
   getModelsForProvider: (baseUrl) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     return store.getState().modelsFromAllProviders[normalized] || [];
   },
   getDisabledProviders: () => store.getState().disabledProviders,
   getProviderMints: (baseUrl) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     return store.getState().mintsFromAllProviders[normalized] || [];
   },
   getProviderInfo: async (baseUrl) => {
-    const normalized = normalizeBaseUrl4(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const cached = store.getState().infoFromAllProviders[normalized];
     if (cached) return cached;
     try {
@@ -4099,7 +4411,7 @@ var getDefaultUsageTrackingDriver = () => {
     return defaultUsageTrackingDriver;
   }
   if (isBun3()) {
-    defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
+    defaultUsageTrackingDriver = createBunSqliteUsageTrackingDriver();
     return defaultUsageTrackingDriver;
   }
   if (isNode()) {
@@ -4111,21 +4423,28 @@ var getDefaultUsageTrackingDriver = () => {
   defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
   return defaultUsageTrackingDriver;
 };
+var setDefaultUsageTrackingDriver = (driver) => {
+  defaultUsageTrackingDriver = driver;
+};
 var getDefaultDiscoveryAdapter = async () => createDiscoveryAdapterFromStore(await getDefaultSdkStore());
 var getDefaultStorageAdapter = async () => createStorageAdapterFromStore(await getDefaultSdkStore());
 var getDefaultProviderRegistry = async () => createProviderRegistryFromStore(await getDefaultSdkStore());
 function createSSEParserTransform(onUsage, onResponseId) {
   let buffer = "";
+  let usageCaptured = false;
+  let responseIdCaptured = false;
   const maybeCaptureUsageFromJson = (jsonText) => {
     try {
       const data = JSON.parse(jsonText);
       const responseId = data.id;
       if (typeof responseId === "string" && responseId.trim().length > 0) {
         onResponseId?.(responseId.trim());
+        responseIdCaptured = true;
       }
       const usage = extractUsageFromSSEJson(data);
       if (usage) {
         onUsage(usage);
+        usageCaptured = true;
       }
     } catch {
     }
@@ -4181,7 +4500,7 @@ function createSSEParserTransform(onUsage, onResponseId) {
 }
 var TOPUP_MARGIN = 1.2;
 var RoutstrClient = class {
-  constructor(walletAdapter, storageAdapter, providerRegistry, alertLevel, mode = "xcashu") {
+  constructor(walletAdapter, storageAdapter, providerRegistry, alertLevel, mode = "xcashu", options = {}) {
     this.walletAdapter = walletAdapter;
     this.storageAdapter = storageAdapter;
     this.providerRegistry = providerRegistry;
@@ -4197,15 +4516,11 @@ var RoutstrClient = class {
       this.balanceManager
     );
     this.streamProcessor = new StreamProcessor();
-    this.providerManager = new ProviderManager(providerRegistry);
     this.alertLevel = alertLevel;
-    if (mode === "lazyrefund") {
-      this.mode = "apikeys";
-    } else if (mode === "apikeys") {
-      this.mode = "lazyrefund";
-    } else {
-      this.mode = mode;
-    }
+    this.mode = mode;
+    this.usageTrackingDriver = options.usageTrackingDriver;
+    this.sdkStore = options.sdkStore;
+    this.providerManager = options.providerManager ?? new ProviderManager(providerRegistry, this.sdkStore);
   }
   cashuSpender;
   balanceManager;
@@ -4214,6 +4529,8 @@ var RoutstrClient = class {
   alertLevel;
   mode;
   debugLevel = "WARN";
+  usageTrackingDriver;
+  sdkStore;
   /**
    * Get the current client mode
    */
@@ -4283,11 +4600,13 @@ var RoutstrClient = class {
     const satsSpent = await this._handlePostResponseBalanceUpdate({
       token: prepared.tokenUsed,
       baseUrl: prepared.baseUrlUsed,
+      mintUrl: params.mintUrl,
       initialTokenBalance: prepared.tokenBalanceInSats,
       response: prepared.response,
       modelId: prepared.modelId,
       usage: prepared.capturedUsage,
-      requestId: prepared.capturedResponseId
+      requestId: prepared.capturedResponseId,
+      clientApiKey: prepared.clientApiKey
     });
     prepared.response.satsSpent = satsSpent;
     prepared.response.usage = prepared.capturedUsage;
@@ -4306,11 +4625,13 @@ var RoutstrClient = class {
       const satsSpent = await this._handlePostResponseBalanceUpdate({
         token: prepared.tokenUsed,
         baseUrl: prepared.baseUrlUsed,
+        mintUrl: params.mintUrl,
         initialTokenBalance: prepared.tokenBalanceInSats,
         response: prepared.response,
         modelId: prepared.modelId,
         usage: prepared.capturedUsage,
-        requestId: prepared.capturedResponseId
+        requestId: prepared.capturedResponseId,
+        clientApiKey: prepared.clientApiKey
       });
       prepared.response.satsSpent = satsSpent;
       res.end();
@@ -4326,11 +4647,13 @@ var RoutstrClient = class {
           const satsSpent = await this._handlePostResponseBalanceUpdate({
             token: prepared.tokenUsed,
             baseUrl: prepared.baseUrlUsed,
+            mintUrl: params.mintUrl,
             initialTokenBalance: prepared.tokenBalanceInSats,
             response: prepared.response,
             modelId: prepared.modelId,
             usage: prepared.capturedUsage,
-            requestId: prepared.capturedResponseId
+            requestId: prepared.capturedResponseId,
+            clientApiKey: prepared.clientApiKey
           });
           prepared.response.satsSpent = satsSpent;
           prepared.response.usage = prepared.capturedUsage;
@@ -4360,8 +4683,10 @@ var RoutstrClient = class {
       headers = {},
       baseUrl,
       mintUrl,
-      modelId
+      modelId,
+      clientApiKey: providedClientApiKey
     } = params;
+    const clientApiKey = providedClientApiKey ?? this._extractClientApiKey(headers);
     await this._checkBalance();
     let requiredSats = 1;
     let selectedModel;
@@ -4383,7 +4708,6 @@ var RoutstrClient = class {
       amount: requiredSats,
       baseUrl
     });
-    this._log("DEBUG", token, baseUrl);
     let requestBody = body;
     if (body && typeof body === "object") {
       const bodyObj = body;
@@ -4391,7 +4715,7 @@ var RoutstrClient = class {
         requestBody = { ...bodyObj, stream: false };
       }
     }
-    const baseHeaders = this._buildBaseHeaders(headers);
+    const baseHeaders = this._buildBaseHeaders();
     const requestHeaders = this._withAuthHeader(baseHeaders, token);
     const response = await this._makeRequest({
       path,
@@ -4443,9 +4767,21 @@ var RoutstrClient = class {
       tokenBalanceInSats,
       modelId,
       capturedUsage,
-      capturedResponseId
+      capturedResponseId,
+      clientApiKey
     };
   }
+  /**
+   * Extract clientApiKey from Authorization Bearer token if present
+   */
+  _extractClientApiKey(headers) {
+    const authHeader = headers["Authorization"] || headers["authorization"];
+    if (authHeader?.startsWith("Bearer ")) {
+      const extractedKey = authHeader.slice(7);
+      return extractedKey;
+    }
+    return void 0;
+  }
   /**
    * Fetch AI response with streaming
    */
@@ -4549,6 +4885,7 @@ var RoutstrClient = class {
         let satsSpent = await this._handlePostResponseBalanceUpdate({
           token,
           baseUrl: baseUrlUsed,
+          mintUrl,
           initialTokenBalance: tokenBalanceInSats,
           fallbackSatsSpent: isApikeysEstimate ? this._getEstimatedCosts(selectedModel, streamingResult) : void 0,
           response,
@@ -4587,7 +4924,6 @@ var RoutstrClient = class {
     try {
       const url = `${baseUrl.replace(/\/$/, "")}${path}`;
       if (this.mode === "xcashu") this._log("DEBUG", "HEADERS,", headers);
-      this._log("DEBUG", "HEADERS,", headers);
       const response = await fetch(url, {
         method,
         headers,
@@ -4656,8 +4992,6 @@ var RoutstrClient = class {
           `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${tryReceiveTokenResult.amount}`
         );
         tryNextProvider = true;
-        if (this.mode === "lazyrefund")
-          this.storageAdapter.removeToken(baseUrl);
       } else {
         this._log(
           "DEBUG",
@@ -4705,24 +5039,21 @@ var RoutstrClient = class {
           );
       }
     }
-    if (status === 402 && !tryNextProvider && (this.mode === "apikeys" || this.mode === "lazyrefund")) {
+    if (status === 402 && !tryNextProvider && this.mode === "apikeys") {
       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 currentBalanceInfo = await this.balanceManager.getTokenBalance(
+          params.token,
+          baseUrl
+        );
+        const currentBalance = currentBalanceInfo.unit === "msat" ? currentBalanceInfo.amount / 1e3 : currentBalanceInfo.amount;
         const shortfall = Math.max(0, params.requiredSats - currentBalance);
         topupAmount = shortfall > 0 ? shortfall : params.requiredSats;
+        this._log(
+          "DEBUG",
+          `The shortfall is: ${shortfall}. requiredSats: ${params.requiredSats}. Current Balance: ${currentBalance} `
+        );
       } catch (e) {
         this._log(
           "WARN",
@@ -4852,61 +5183,49 @@ var RoutstrClient = class {
         tryNextProvider = true;
       }
     }
+    if (status === 401 && this.mode === "apikeys") {
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Checking balance for ${baseUrl}, key preview=${token}`
+      );
+      const latestBalanceInfo = await this.balanceManager.getTokenBalance(
+        token,
+        baseUrl
+      );
+      if (latestBalanceInfo.isInvalidApiKey) {
+        this.storageAdapter.removeApiKey(baseUrl);
+        tryNextProvider = true;
+      }
+    }
     if ((status === 401 || status === 403 || status === 413 || status === 400 || status === 500 || status === 502 || status === 503 || status === 504 || status === 521) && !tryNextProvider) {
       this._log(
         "DEBUG",
         `[RoutstrClient] _handleErrorResponse: Status ${status} (auth/server error), attempting refund for ${baseUrl}, mode=${this.mode}`
       );
-      if (this.mode === "lazyrefund") {
-        try {
-          const refundResult = await this.balanceManager.refund({
-            mintUrl,
-            baseUrl,
-            token: params.token
-          });
-          this._log(
-            "DEBUG",
-            `[RoutstrClient] _handleErrorResponse: Lazyrefund result: success=${refundResult.success}`
-          );
-          if (refundResult.success) this.storageAdapter.removeToken(baseUrl);
-          else
-            throw new ProviderError(
-              baseUrl,
-              status,
-              "refund failed",
-              requestId
-            );
-        } catch (error) {
-          throw new ProviderError(
-            baseUrl,
-            status,
-            "Failed to refund token",
-            requestId
-          );
-        }
-      } else if (this.mode === "apikeys") {
+      if (this.mode === "apikeys") {
         this._log(
           "DEBUG",
           `[RoutstrClient] _handleErrorResponse: Attempting API key refund for ${baseUrl}, key preview=${token}`
         );
-        const initialBalance = await this.balanceManager.getTokenBalance(
+        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
           token,
           baseUrl
         );
         this._log(
           "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Initial API key balance: ${initialBalance.amount}`
+          `[RoutstrClient] _handleErrorResponse: Initial API key balance: ${latestBalanceInfo.amount}`
         );
         const refundResult = await this.balanceManager.refundApiKey({
           mintUrl,
           baseUrl,
-          apiKey: token
+          apiKey: token,
+          forceRefund: true
         });
         this._log(
           "DEBUG",
           `[RoutstrClient] _handleErrorResponse: API key refund result: success=${refundResult.success}, message=${refundResult.message}`
         );
-        if (!refundResult.success && initialBalance.amount > 0) {
+        if (!refundResult.success && latestBalanceInfo.amount > 0) {
           throw new ProviderError(
             baseUrl,
             status,
@@ -4982,12 +5301,14 @@ var RoutstrClient = class {
     const {
       token,
       baseUrl,
+      mintUrl,
       initialTokenBalance,
       fallbackSatsSpent,
       response,
       modelId,
       usage,
-      requestId
+      requestId,
+      clientApiKey
     } = params;
     let satsSpent = initialTokenBalance;
     if (this.mode === "xcashu" && response) {
@@ -4995,19 +5316,14 @@ var RoutstrClient = class {
       if (refundToken) {
         try {
           const receiveResult = await this.cashuSpender.receiveToken(refundToken);
-          satsSpent = initialTokenBalance - receiveResult.amount * (receiveResult.unit == "sat" ? 1 : 1e3);
+          if (receiveResult.success) {
+            this.storageAdapter.removeXcashuToken(baseUrl, token);
+            satsSpent = initialTokenBalance - receiveResult.amount * (receiveResult.unit == "sat" ? 1 : 1e3);
+          }
         } catch (error) {
           this._log("ERROR", "[xcashu] Failed to receive refund token:", error);
         }
       }
-    } else if (this.mode === "lazyrefund") {
-      const latestBalanceInfo = await this.balanceManager.getTokenBalance(
-        token,
-        baseUrl
-      );
-      const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
-      this.storageAdapter.updateTokenBalance(baseUrl, latestTokenBalance);
-      satsSpent = initialTokenBalance - latestTokenBalance;
     } else if (this.mode === "apikeys") {
       try {
         const latestBalanceInfo = await this.balanceManager.getTokenBalance(
@@ -5042,8 +5358,17 @@ var RoutstrClient = class {
       modelId,
       satsSpent,
       usage,
-      requestId
+      requestId,
+      clientApiKey
     });
+    (async () => {
+      try {
+        const xcashuResults = await this.cashuSpender.refundXcashuTokens(mintUrl);
+        this._log("DEBUG", "Refund xcashu tokens results:", xcashuResults);
+      } catch (error) {
+        this._log("ERROR", "Failed to refund providers:", error);
+      }
+    })();
     return satsSpent;
   }
   async _trackResponseUsage(params) {
@@ -5054,7 +5379,8 @@ var RoutstrClient = class {
       modelId,
       satsSpent,
       usage: providedUsage,
-      requestId: providedRequestId
+      requestId: providedRequestId,
+      clientApiKey
     } = params;
     if (!response || !modelId) {
       return;
@@ -5081,13 +5407,14 @@ var RoutstrClient = class {
         return;
       }
       const finalRequestId = requestId || "unknown";
-      const store = await getDefaultSdkStore();
+      const store = this.sdkStore ?? await getDefaultSdkStore();
       const state = store.getState();
+      const matchKey = clientApiKey ?? token;
       const matchingClient = state.clientIds.find(
-        (client) => client.apiKey === token
+        (client) => client.apiKey === matchKey
       );
       const entryId = finalRequestId === "unknown" ? `req-${Date.now()}-${modelId}` : finalRequestId;
-      const usageTracking = getDefaultUsageTrackingDriver();
+      const usageTracking = this.usageTrackingDriver ?? getDefaultUsageTrackingDriver();
       const entry = {
         id: entryId,
         timestamp: Date.now(),
@@ -5162,11 +5489,11 @@ var RoutstrClient = class {
     return estimatedCosts;
   }
   /**
-   * Get pending cashu token amount
+   * Get pending API key amount
    */
   _getPendingCashuTokenAmount() {
-    const distribution = this.storageAdapter.getCachedTokenDistribution();
-    return distribution.reduce((total, item) => total + item.amount, 0);
+    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+    return apiKeyDistribution.reduce((total, item) => total + item.amount, 0);
   }
   /**
    * Handle errors and notify callbacks
@@ -5313,8 +5640,8 @@ var RoutstrClient = class {
     const spendResult = await this.cashuSpender.spend({
       mintUrl,
       amount,
-      baseUrl: this.mode === "lazyrefund" ? baseUrl : "",
-      reuseToken: this.mode === "lazyrefund"
+      baseUrl: "",
+      reuseToken: false
     });
     if (!spendResult.token) {
       this._log(
@@ -5327,6 +5654,7 @@ var RoutstrClient = class {
         "DEBUG",
         `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult.token}, balance: ${spendResult.balance} ${spendResult.unit ?? "sat"}`
       );
+      this.storageAdapter.addXcashuToken(baseUrl, spendResult.token);
     }
     return {
       token: spendResult.token,
@@ -5364,6 +5692,7 @@ async function resolveRouteRequestContext(options) {
     modelId,
     requestBody,
     path = "/v1/chat/completions",
+    headers = {},
     forcedProvider,
     walletAdapter,
     storageAdapter,
@@ -5374,7 +5703,10 @@ async function resolveRouteRequestContext(options) {
     forceRefresh = false,
     modelManager: providedModelManager,
     debugLevel,
-    mode = "apikeys"
+    mode = "apikeys",
+    usageTrackingDriver,
+    sdkStore,
+    providerManager: providedProviderManager
   } = options;
   let modelManager;
   let providers;
@@ -5394,7 +5726,7 @@ async function resolveRouteRequestContext(options) {
     }
     await modelManager.fetchModels(providers, forceRefresh);
   }
-  const providerManager = new ProviderManager(providerRegistry);
+  const providerManager = providedProviderManager ?? new ProviderManager(providerRegistry, sdkStore);
   let baseUrl;
   let selectedModel;
   if (forcedProvider) {
@@ -5438,7 +5770,8 @@ async function resolveRouteRequestContext(options) {
     storageAdapter,
     providerRegistry,
     "min",
-    mode
+    mode,
+    { usageTrackingDriver, sdkStore, providerManager }
   );
   if (debugLevel) {
     client.setDebugLevel(debugLevel);
@@ -5458,17 +5791,19 @@ async function resolveRouteRequestContext(options) {
     baseUrl,
     mintUrl,
     path,
+    headers,
     modelId,
     proxiedBody
   };
 }
 async function routeRequests(options) {
-  const { client, baseUrl, mintUrl, path, modelId, proxiedBody } = await resolveRouteRequestContext(options);
+  const { client, baseUrl, mintUrl, path, headers, modelId, proxiedBody } = await resolveRouteRequestContext(options);
   try {
     const response = await client.routeRequest({
       path,
       method: "POST",
       body: proxiedBody,
+      headers,
       baseUrl,
       mintUrl,
       modelId
@@ -5486,12 +5821,13 @@ async function routeRequests(options) {
 }
 async function routeRequestsToNodeResponse(options) {
   const { res } = options;
-  const { client, baseUrl, mintUrl, path, modelId, proxiedBody } = await resolveRouteRequestContext(options);
+  const { client, baseUrl, mintUrl, path, headers, modelId, proxiedBody } = await resolveRouteRequestContext(options);
   try {
     await client.routeRequestToNodeResponse({
       path,
       method: "POST",
       body: proxiedBody,
+      headers,
       baseUrl,
       mintUrl,
       modelId,
@@ -5539,6 +5875,8 @@ exports.SDK_STORAGE_KEYS = SDK_STORAGE_KEYS;
 exports.StreamProcessor = StreamProcessor;
 exports.StreamingError = StreamingError;
 exports.TokenOperationError = TokenOperationError;
+exports.createBunSqliteDriver = createBunSqliteDriver;
+exports.createBunSqliteUsageTrackingDriver = createBunSqliteUsageTrackingDriver;
 exports.createDiscoveryAdapterFromStore = createDiscoveryAdapterFromStore;
 exports.createIndexedDBDriver = createIndexedDBDriver;
 exports.createIndexedDBUsageTrackingDriver = createIndexedDBUsageTrackingDriver;
@@ -5564,5 +5902,6 @@ exports.localStorageDriver = localStorageDriver;
 exports.normalizeProviderUrl = normalizeProviderUrl;
 exports.routeRequests = routeRequests;
 exports.routeRequestsToNodeResponse = routeRequestsToNodeResponse;
+exports.setDefaultUsageTrackingDriver = setDefaultUsageTrackingDriver;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map