@routstr/sdk 0.2.5 → 0.2.6

package/dist/client/index.mjs

@@ -1,14 +1,6 @@
 import { createStore } from 'zustand/vanilla';
-import { getDecodedToken } from '@cashu/cashu-ts';
 import { Transform, Readable } from '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) {
@@ -152,13 +144,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]) {
@@ -379,27 +366,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,
@@ -420,19 +391,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
@@ -443,7 +414,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) {
@@ -457,7 +429,7 @@ var CashuSpender = class {
           status: "success"
         });
         return {
-          token: storedToken,
+          token: apiKeyEntry.key,
           status: "success",
           balance: newBalance,
           unit
@@ -465,84 +437,108 @@ 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 and increment tryCounts on failure.
+   * Reuses receiveToken from BalanceManager/CashuSpender for receiving refunds.
+   * @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 {
+          const receiveResult = await this.receiveToken(xcashuToken.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 refund xcashu 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;
@@ -627,13 +623,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]) {
@@ -648,57 +639,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
@@ -834,8 +774,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;
@@ -855,7 +796,7 @@ var BalanceManager = class {
       cashuToken = tokenResult.token;
       const topUpResult = await this._postTopUp(
         baseUrl,
-        storedToken,
+        apiKey,
         cashuToken
       );
       requestId = topUpResult.requestId;
@@ -1070,38 +1011,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(
@@ -1125,77 +1039,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
    */
@@ -2179,38 +2022,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 {
@@ -2228,6 +2087,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);
@@ -2235,6 +2095,7 @@ var createSqliteDriver = (options = {}) => {
     },
     async removeItem(key) {
       try {
+        await ensureInit();
         deleteStmt.run(key);
       } catch (error) {
         console.error(`SQLite removeItem failed for key "${key}":`, error);
@@ -2253,9 +2114,9 @@ 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",
@@ -2446,21 +2307,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 = [];
@@ -2497,38 +2360,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,
@@ -2586,19 +2460,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 ?" : "";
@@ -2611,6 +2489,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}`);
@@ -2618,20 +2497,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;
@@ -2642,7 +2698,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) {
@@ -2656,18 +2712,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 = {}) {
@@ -2695,20 +2751,7 @@ var createMemoryUsageTrackingDriver = (seed = []) => {
     }
   };
 };
-var normalizeBaseUrl4 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var getCashuTokenBalance = (token) => {
-  try {
-    const decoded = 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) => createStore((set, get) => ({
   modelsFromAllProviders: {},
   lastUsedModel: null,
@@ -2718,9 +2761,9 @@ var createEmptyStore = (driver) => createStore((set, get) => ({
   mintsFromAllProviders: {},
   infoFromAllProviders: {},
   lastModelsUpdate: {},
-  cachedTokens: [],
   apiKeys: [],
   childKeys: [],
+  xcashuTokens: {},
   routstr21Models: [],
   lastRoutstr21ModelsUpdate: null,
   cachedReceiveTokens: [],
@@ -2728,7 +2771,7 @@ var createEmptyStore = (driver) => createStore((set, get) => ({
   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,
@@ -2741,7 +2784,7 @@ var createEmptyStore = (driver) => 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 });
   },
@@ -2750,14 +2793,14 @@ var createEmptyStore = (driver) => 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
       );
     }
@@ -2770,7 +2813,7 @@ var createEmptyStore = (driver) => 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 });
@@ -2778,30 +2821,17 @@ var createEmptyStore = (driver) => 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
       }));
@@ -2813,7 +2843,7 @@ var createEmptyStore = (driver) => 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,
@@ -2824,6 +2854,30 @@ var createEmptyStore = (driver) => 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 });
@@ -2865,9 +2919,9 @@ var hydrateStoreFromDriver = async (store, driver) => {
     rawMints,
     rawInfo,
     rawLastModelsUpdate,
-    rawCachedTokens,
     rawApiKeys,
     rawChildKeys,
+    rawXcashuTokens,
     rawRoutstr21Models,
     rawLastRoutstr21ModelsUpdate,
     rawCachedReceiveTokens,
@@ -2893,9 +2947,9 @@ 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,
@@ -2906,52 +2960,57 @@ var hydrateStoreFromDriver = async (store, driver) => {
   ]);
   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) => ({
@@ -2974,9 +3033,9 @@ var hydrateStoreFromDriver = async (store, driver) => {
     mintsFromAllProviders,
     infoFromAllProviders,
     lastModelsUpdate,
-    cachedTokens,
     apiKeys,
     childKeys,
+    xcashuTokens,
     routstr21Models,
     lastRoutstr21ModelsUpdate,
     cachedReceiveTokens,
@@ -3047,7 +3106,7 @@ var getDefaultUsageTrackingDriver = () => {
     return defaultUsageTrackingDriver;
   }
   if (isBun3()) {
-    defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
+    defaultUsageTrackingDriver = createBunSqliteUsageTrackingDriver();
     return defaultUsageTrackingDriver;
   }
   if (isNode()) {
@@ -3061,16 +3120,20 @@ var getDefaultUsageTrackingDriver = () => {
 };
 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 {
     }
@@ -3126,7 +3189,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;
@@ -3144,13 +3207,9 @@ var RoutstrClient = class {
     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;
   }
   cashuSpender;
   balanceManager;
@@ -3159,6 +3218,8 @@ var RoutstrClient = class {
   alertLevel;
   mode;
   debugLevel = "WARN";
+  usageTrackingDriver;
+  sdkStore;
   /**
    * Get the current client mode
    */
@@ -3228,11 +3289,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;
@@ -3251,11 +3314,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();
@@ -3271,11 +3336,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;
@@ -3305,8 +3372,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;
@@ -3328,7 +3397,6 @@ var RoutstrClient = class {
       amount: requiredSats,
       baseUrl
     });
-    this._log("DEBUG", token, baseUrl);
     let requestBody = body;
     if (body && typeof body === "object") {
       const bodyObj = body;
@@ -3336,7 +3404,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,
@@ -3388,9 +3456,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
    */
@@ -3494,6 +3574,7 @@ var RoutstrClient = class {
         let satsSpent = await this._handlePostResponseBalanceUpdate({
           token,
           baseUrl: baseUrlUsed,
+          mintUrl,
           initialTokenBalance: tokenBalanceInSats,
           fallbackSatsSpent: isApikeysEstimate ? this._getEstimatedCosts(selectedModel, streamingResult) : void 0,
           response,
@@ -3532,7 +3613,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,
@@ -3601,8 +3681,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",
@@ -3650,22 +3728,15 @@ 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;
       } catch (e) {
@@ -3802,34 +3873,7 @@ var RoutstrClient = class {
         "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}`
@@ -3845,7 +3889,8 @@ var RoutstrClient = class {
         const refundResult = await this.balanceManager.refundApiKey({
           mintUrl,
           baseUrl,
-          apiKey: token
+          apiKey: token,
+          forceRefund: true
         });
         this._log(
           "DEBUG",
@@ -3927,12 +3972,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) {
@@ -3940,19 +3987,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(
@@ -3987,8 +4029,18 @@ 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);
+        const results = await this.cashuSpender.refundProviders(mintUrl);
+      } catch (error) {
+        this._log("ERROR", "Failed to refund providers:", error);
+      }
+    })();
     return satsSpent;
   }
   async _trackResponseUsage(params) {
@@ -3999,7 +4051,8 @@ var RoutstrClient = class {
       modelId,
       satsSpent,
       usage: providedUsage,
-      requestId: providedRequestId
+      requestId: providedRequestId,
+      clientApiKey
     } = params;
     if (!response || !modelId) {
       return;
@@ -4026,13 +4079,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(),
@@ -4107,11 +4161,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
@@ -4258,8 +4312,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(
@@ -4272,6 +4326,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,