@routstr/sdk 0.2.5 → 0.2.6

package/dist/storage/index.mjs

@@ -1,12 +1,4 @@
 import { createStore } from 'zustand/vanilla';
-import { getDecodedToken } from '@cashu/cashu-ts';
-
-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');
-});
 
 // storage/drivers/localStorage.ts
 var canUseLocalStorage = () => {
@@ -120,38 +112,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 {
@@ -169,6 +177,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);
@@ -176,6 +185,7 @@ var createSqliteDriver = (options = {}) => {
     },
     async removeItem(key) {
       try {
+        await ensureInit();
         deleteStmt.run(key);
       } catch (error) {
         console.error(`SQLite removeItem failed for key "${key}":`, error);
@@ -183,6 +193,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";
@@ -288,9 +346,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",
@@ -481,21 +539,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 = [];
@@ -532,38 +592,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,
@@ -621,19 +692,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 ?" : "";
@@ -646,6 +721,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}`);
@@ -653,20 +729,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;
@@ -677,7 +930,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) {
@@ -691,18 +944,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 = {}) {
@@ -730,20 +983,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,
@@ -753,9 +993,9 @@ var createEmptyStore = (driver) => createStore((set, get) => ({
   mintsFromAllProviders: {},
   infoFromAllProviders: {},
   lastModelsUpdate: {},
-  cachedTokens: [],
   apiKeys: [],
   childKeys: [],
+  xcashuTokens: {},
   routstr21Models: [],
   lastRoutstr21ModelsUpdate: null,
   cachedReceiveTokens: [],
@@ -763,7 +1003,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,
@@ -776,7 +1016,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 });
   },
@@ -785,14 +1025,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
       );
     }
@@ -805,7 +1045,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 });
@@ -813,30 +1053,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
       }));
@@ -848,7 +1075,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,
@@ -859,6 +1086,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 });
@@ -900,9 +1151,9 @@ var hydrateStoreFromDriver = async (store, driver) => {
     rawMints,
     rawInfo,
     rawLastModelsUpdate,
-    rawCachedTokens,
     rawApiKeys,
     rawChildKeys,
+    rawXcashuTokens,
     rawRoutstr21Models,
     rawLastRoutstr21ModelsUpdate,
     rawCachedReceiveTokens,
@@ -928,9 +1179,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,
@@ -941,52 +1192,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) => ({
@@ -1009,9 +1265,9 @@ var hydrateStoreFromDriver = async (store, driver) => {
     mintsFromAllProviders,
     infoFromAllProviders,
     lastModelsUpdate,
-    cachedTokens,
     apiKeys,
     childKeys,
+    xcashuTokens,
     routstr21Models,
     lastRoutstr21ModelsUpdate,
     cachedReceiveTokens,
@@ -1035,12 +1291,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);
@@ -1058,59 +1314,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 = {};
@@ -1123,28 +1326,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
@@ -1162,15 +1361,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);
   },
@@ -1184,7 +1383,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 {
@@ -1197,7 +1396,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
@@ -1228,7 +1427,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
@@ -1236,7 +1435,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);
   },
@@ -1255,20 +1454,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 {
@@ -1343,7 +1582,7 @@ var getDefaultUsageTrackingDriver = () => {
     return defaultUsageTrackingDriver;
   }
   if (isBun3()) {
-    defaultUsageTrackingDriver = createMemoryUsageTrackingDriver();
+    defaultUsageTrackingDriver = createBunSqliteUsageTrackingDriver();
     return defaultUsageTrackingDriver;
   }
   if (isNode()) {
@@ -1355,10 +1594,13 @@ 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());
 
-export { SDK_STORAGE_KEYS, createDiscoveryAdapterFromStore, createIndexedDBDriver, createIndexedDBUsageTrackingDriver, createMemoryDriver, createMemoryUsageTrackingDriver, createProviderRegistryFromStore, createSdkStore, createSqliteDriver, createSqliteUsageTrackingDriver, createStorageAdapterFromStore, getDefaultDiscoveryAdapter, getDefaultProviderRegistry, getDefaultSdkDriver, getDefaultSdkStore, getDefaultStorageAdapter, getDefaultUsageTrackingDriver, localStorageDriver };
+export { SDK_STORAGE_KEYS, createBunSqliteDriver, createBunSqliteUsageTrackingDriver, createDiscoveryAdapterFromStore, createIndexedDBDriver, createIndexedDBUsageTrackingDriver, createMemoryDriver, createMemoryUsageTrackingDriver, createProviderRegistryFromStore, createSdkStore, createSqliteDriver, createSqliteUsageTrackingDriver, createStorageAdapterFromStore, getDefaultDiscoveryAdapter, getDefaultProviderRegistry, getDefaultSdkDriver, getDefaultSdkStore, getDefaultStorageAdapter, getDefaultUsageTrackingDriver, localStorageDriver, setDefaultUsageTrackingDriver };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map