@routstr/sdk 0.2.4 → 0.2.6

package/dist/storage/index.js

@@ -1,14 +1,6 @@
 'use strict';
 
 var vanilla = require('zustand/vanilla');
-var cashuTs = require('@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 = () => {
@@ -122,38 +114,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 {
@@ -171,6 +179,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);
@@ -178,6 +187,7 @@ var createSqliteDriver = (options = {}) => {
     },
     async removeItem(key) {
       try {
+        await ensureInit();
         deleteStmt.run(key);
       } catch (error) {
         console.error(`SQLite removeItem failed for key "${key}":`, error);
@@ -185,6 +195,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";
@@ -290,9 +348,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",
@@ -300,21 +358,634 @@ var SDK_STORAGE_KEYS = {
   CLIENT_IDS: "client_ids"
 };
 
-// storage/store.ts
+// storage/usageTracking/indexedDB.ts
+var DEFAULT_DB_NAME = "routstr-sdk";
+var DEFAULT_STORE_NAME = "usage_tracking";
+var MIGRATION_MARKER_KEY = "usage_tracking_migration_v1";
+var isBrowser2 = typeof indexedDB !== "undefined";
 var normalizeBaseUrl = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
-var getCashuTokenBalance = (token) => {
+var openDatabase2 = (dbName, storeName) => {
+  if (!isBrowser2) {
+    return Promise.reject(new Error("IndexedDB is not available"));
+  }
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(dbName, 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        const store = db.createObjectStore(storeName, { keyPath: "id" });
+        store.createIndex("timestamp", "timestamp", { unique: false });
+        store.createIndex("modelId", "modelId", { unique: false });
+        store.createIndex("baseUrl", "baseUrl", { unique: false });
+        store.createIndex("sessionId", "sessionId", { unique: false });
+        store.createIndex("client", "client", { unique: false });
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+};
+var matchesFilters = (entry, options = {}) => {
+  if (typeof options.before === "number" && entry.timestamp >= options.before) {
+    return false;
+  }
+  if (typeof options.after === "number" && entry.timestamp <= options.after) {
+    return false;
+  }
+  if (options.modelId && entry.modelId !== options.modelId) {
+    return false;
+  }
+  if (options.baseUrl && normalizeBaseUrl(entry.baseUrl) !== normalizeBaseUrl(options.baseUrl)) {
+    return false;
+  }
+  if (options.sessionId && entry.sessionId !== options.sessionId) {
+    return false;
+  }
+  if (options.client && entry.client !== options.client) {
+    return false;
+  }
+  return true;
+};
+var createIndexedDBUsageTrackingDriver = (options = {}) => {
+  const dbName = options.dbName || DEFAULT_DB_NAME;
+  const storeName = options.storeName || DEFAULT_STORE_NAME;
+  const legacyStorageDriver = options.legacyStorageDriver;
+  let dbPromise = null;
+  let migrationPromise = null;
+  const getDb = () => {
+    if (!dbPromise) {
+      dbPromise = openDatabase2(dbName, storeName);
+    }
+    return dbPromise;
+  };
+  const putMany = async (entries) => {
+    if (entries.length === 0) return;
+    const db = await getDb();
+    await new Promise((resolve, reject) => {
+      const tx = db.transaction(storeName, "readwrite");
+      const store = tx.objectStore(storeName);
+      for (const entry of entries) {
+        store.put({ ...entry, baseUrl: normalizeBaseUrl(entry.baseUrl) });
+      }
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  };
+  const ensureMigrated = async () => {
+    if (!legacyStorageDriver) return;
+    if (!migrationPromise) {
+      migrationPromise = (async () => {
+        const migrated = await legacyStorageDriver.getItem(
+          MIGRATION_MARKER_KEY,
+          false
+        );
+        if (migrated) return;
+        const legacyEntries = await legacyStorageDriver.getItem(
+          SDK_STORAGE_KEYS.USAGE_TRACKING,
+          []
+        );
+        if (legacyEntries.length > 0) {
+          await putMany(legacyEntries);
+          await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
+        }
+        await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY, true);
+      })();
+    }
+    await migrationPromise;
+  };
+  return {
+    async migrate() {
+      await ensureMigrated();
+    },
+    async append(entry) {
+      await ensureMigrated();
+      await putMany([entry]);
+    },
+    async appendMany(entries) {
+      await ensureMigrated();
+      await putMany(entries);
+    },
+    async list(options2 = {}) {
+      await ensureMigrated();
+      const db = await getDb();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readonly");
+        const store = tx.objectStore(storeName);
+        const index = store.index("timestamp");
+        const direction = "prev";
+        const request = index.openCursor(null, direction);
+        const results = [];
+        const limit = options2.limit;
+        request.onsuccess = () => {
+          const cursor = request.result;
+          if (!cursor) {
+            resolve(results);
+            return;
+          }
+          const value = cursor.value;
+          if (matchesFilters(value, options2)) {
+            results.push(value);
+            if (typeof limit === "number" && results.length >= limit) {
+              resolve(results);
+              return;
+            }
+          }
+          cursor.continue();
+        };
+        request.onerror = () => reject(request.error);
+      });
+    },
+    async count(options2 = {}) {
+      const results = await this.list(options2);
+      return results.length;
+    },
+    async deleteOlderThan(timestamp) {
+      await ensureMigrated();
+      const db = await getDb();
+      return new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readwrite");
+        const store = tx.objectStore(storeName);
+        const index = store.index("timestamp");
+        const range = IDBKeyRange.upperBound(timestamp, true);
+        const request = index.openCursor(range);
+        let deleted = 0;
+        request.onsuccess = () => {
+          const cursor = request.result;
+          if (!cursor) {
+            resolve(deleted);
+            return;
+          }
+          deleted += 1;
+          cursor.delete();
+          cursor.continue();
+        };
+        request.onerror = () => reject(request.error);
+      });
+    },
+    async clear() {
+      await ensureMigrated();
+      const db = await getDb();
+      await new Promise((resolve, reject) => {
+        const tx = db.transaction(storeName, "readwrite");
+        tx.objectStore(storeName).clear();
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+      });
+    }
+  };
+};
+
+// storage/usageTracking/sqlite.ts
+var MIGRATION_MARKER_KEY2 = "usage_tracking_migration_v1";
+var normalizeBaseUrl2 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+var isBun2 = () => {
+  return typeof process.versions.bun !== "undefined";
+};
+var cachedDbModule2 = null;
+var loadDatabase2 = async (dbPath) => {
+  if (isBun2()) {
+    throw new Error(
+      "SQLite driver not supported in Bun. Use createMemoryDriver() instead."
+    );
+  }
   try {
-    const decoded = cashuTs.getDecodedToken(token);
-    const unitDivisor = decoded.unit === "msat" ? 1e3 : 1;
-    let sum = 0;
-    for (const proof of decoded.proofs) {
-      sum += proof.amount / unitDivisor;
+    if (!cachedDbModule2) {
+      cachedDbModule2 = (await import('better-sqlite3')).default;
     }
-    return sum;
-  } catch {
-    return 0;
+    return new cachedDbModule2(dbPath);
+  } catch (error) {
+    throw new Error(
+      `better-sqlite3 is required for sqlite usage tracking. Install it to use sqlite storage. (${error})`
+    );
+  }
+};
+var buildWhereClause = (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(normalizeBaseUrl2(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 createSqliteUsageTrackingDriver = (options = {}) => {
+  const dbPath = options.dbPath || "routstr.sqlite";
+  const tableName = options.tableName || "usage_tracking";
+  const legacyStorageDriver = options.legacyStorageDriver;
+  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,
+      entry.timestamp,
+      entry.modelId,
+      normalizeBaseUrl2(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 ensureMigrated = async () => {
+    if (!legacyStorageDriver || migrationComplete) return;
+    const migrated = await legacyStorageDriver.getItem(
+      MIGRATION_MARKER_KEY2,
+      false
+    );
+    if (migrated) {
+      migrationComplete = true;
+      return;
+    }
+    const legacyEntries = await legacyStorageDriver.getItem(
+      SDK_STORAGE_KEYS.USAGE_TRACKING,
+      []
+    );
+    for (const entry of legacyEntries) {
+      appendOne(entry);
+    }
+    if (legacyEntries.length > 0) {
+      await legacyStorageDriver.removeItem(SDK_STORAGE_KEYS.USAGE_TRACKING);
+    }
+    await legacyStorageDriver.setItem(MIGRATION_MARKER_KEY2, true);
+    migrationComplete = true;
+  };
+  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
+  });
+  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 ?" : "";
+      const stmt = db.prepare(
+        `SELECT * FROM ${tableName} ${sql} ORDER BY timestamp DESC${limitSql}`
+      );
+      const rows = stmt.all(
+        ...typeof options2.limit === "number" ? [...params, options2.limit] : params
+      );
+      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}`);
+      const row = stmt.get(...params);
+      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/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;
+  }
+  if (typeof options.after === "number" && entry.timestamp <= options.after) {
+    return false;
+  }
+  if (options.modelId && entry.modelId !== options.modelId) {
+    return false;
+  }
+  if (options.baseUrl && normalizeBaseUrl4(entry.baseUrl) !== normalizeBaseUrl4(options.baseUrl)) {
+    return false;
+  }
+  if (options.sessionId && entry.sessionId !== options.sessionId) {
+    return false;
   }
+  if (options.client && entry.client !== options.client) {
+    return false;
+  }
+  return true;
+};
+var createMemoryUsageTrackingDriver = (seed = []) => {
+  const store = /* @__PURE__ */ new Map();
+  for (const entry of seed) {
+    store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
+  }
+  return {
+    async migrate() {
+      return;
+    },
+    async append(entry) {
+      store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
+    },
+    async appendMany(entries) {
+      for (const entry of entries) {
+        store.set(entry.id, { ...entry, baseUrl: normalizeBaseUrl4(entry.baseUrl) });
+      }
+    },
+    async list(options = {}) {
+      const entries = [...store.values()].filter((entry) => matchesFilters2(entry, options)).sort((a, b) => b.timestamp - a.timestamp);
+      if (typeof options.limit === "number") {
+        return entries.slice(0, options.limit);
+      }
+      return entries;
+    },
+    async count(options = {}) {
+      return (await this.list(options)).length;
+    },
+    async deleteOlderThan(timestamp) {
+      let deleted = 0;
+      for (const [id, entry] of store.entries()) {
+        if (entry.timestamp < timestamp) {
+          store.delete(id);
+          deleted += 1;
+        }
+      }
+      return deleted;
+    },
+    async clear() {
+      store.clear();
+    }
+  };
 };
+var normalizeBaseUrl5 = (baseUrl) => baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
 var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   modelsFromAllProviders: {},
   lastUsedModel: null,
@@ -324,18 +995,17 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   mintsFromAllProviders: {},
   infoFromAllProviders: {},
   lastModelsUpdate: {},
-  cachedTokens: [],
   apiKeys: [],
   childKeys: [],
+  xcashuTokens: {},
   routstr21Models: [],
   lastRoutstr21ModelsUpdate: null,
   cachedReceiveTokens: [],
-  usageTracking: [],
   clientIds: [],
   setModelsFromAllProviders: (value) => {
     const normalized = {};
     for (const [baseUrl, models] of Object.entries(value)) {
-      normalized[normalizeBaseUrl(baseUrl)] = models;
+      normalized[normalizeBaseUrl5(baseUrl)] = models;
     }
     void driver.setItem(
       SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
@@ -348,7 +1018,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     set({ lastUsedModel: value });
   },
   setBaseUrlsList: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl(url));
+    const normalized = value.map((url) => normalizeBaseUrl5(url));
     void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
     set({ baseUrlsList: normalized });
   },
@@ -357,14 +1027,14 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     set({ lastBaseUrlsUpdate: value });
   },
   setDisabledProviders: (value) => {
-    const normalized = value.map((url) => normalizeBaseUrl(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[normalizeBaseUrl(baseUrl)] = mints.map(
+      normalized[normalizeBaseUrl5(baseUrl)] = mints.map(
         (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
       );
     }
@@ -377,7 +1047,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   setInfoFromAllProviders: (value) => {
     const normalized = {};
     for (const [baseUrl, info] of Object.entries(value)) {
-      normalized[normalizeBaseUrl(baseUrl)] = info;
+      normalized[normalizeBaseUrl5(baseUrl)] = info;
     }
     void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
     set({ infoFromAllProviders: normalized });
@@ -385,30 +1055,17 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   setLastModelsUpdate: (value) => {
     const normalized = {};
     for (const [baseUrl, timestamp] of Object.entries(value)) {
-      normalized[normalizeBaseUrl(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: normalizeBaseUrl(entry.baseUrl),
-        balance: typeof entry.balance === "number" ? entry.balance : getCashuTokenBalance(entry.token),
-        lastUsed: entry.lastUsed ?? null
-      }));
-      void driver.setItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, normalized);
-      return { cachedTokens: normalized };
-    });
-  },
   setApiKeys: (value) => {
     set((state) => {
       const updates = typeof value === "function" ? value(state.apiKeys) : value;
       const normalized = updates.map((entry) => ({
         ...entry,
-        baseUrl: normalizeBaseUrl(entry.baseUrl),
+        baseUrl: normalizeBaseUrl5(entry.baseUrl),
         balance: entry.balance ?? 0,
         lastUsed: entry.lastUsed ?? null
       }));
@@ -420,7 +1077,7 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     set((state) => {
       const updates = typeof value === "function" ? value(state.childKeys) : value;
       const normalized = updates.map((entry) => ({
-        parentBaseUrl: normalizeBaseUrl(entry.parentBaseUrl),
+        parentBaseUrl: normalizeBaseUrl5(entry.parentBaseUrl),
         childKey: entry.childKey,
         balance: entry.balance ?? 0,
         balanceLimit: entry.balanceLimit,
@@ -431,6 +1088,30 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
       return { childKeys: normalized };
     });
   },
+  setXcashuTokens: (value) => {
+    const normalized = {};
+    for (const [baseUrl, tokens] of Object.entries(value)) {
+      normalized[normalizeBaseUrl5(baseUrl)] = tokens.map((entry) => ({
+        ...entry,
+        baseUrl: normalizeBaseUrl5(entry.baseUrl),
+        createdAt: entry.createdAt ?? Date.now(),
+        tryCount: entry.tryCount ?? 0
+      }));
+    }
+    void driver.setItem(SDK_STORAGE_KEYS.XCASHU_TOKENS, normalized);
+    set({ xcashuTokens: normalized });
+  },
+  updateXcashuTokenTryCount: (token, tryCount) => {
+    const currentTokens = get().xcashuTokens;
+    const updatedTokens = {};
+    for (const [baseUrl, tokens] of Object.entries(currentTokens)) {
+      updatedTokens[baseUrl] = tokens.map(
+        (entry) => entry.token === token ? { ...entry, tryCount } : entry
+      );
+    }
+    void driver.setItem(SDK_STORAGE_KEYS.XCASHU_TOKENS, updatedTokens);
+    set({ xcashuTokens: updatedTokens });
+  },
   setRoutstr21Models: (value) => {
     void driver.setItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, value);
     set({ routstr21Models: value });
@@ -449,10 +1130,6 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
     void driver.setItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, normalized);
     set({ cachedReceiveTokens: normalized });
   },
-  setUsageTracking: (value) => {
-    void driver.setItem(SDK_STORAGE_KEYS.USAGE_TRACKING, value);
-    set({ usageTracking: value });
-  },
   setClientIds: (value) => {
     set((state) => {
       const updates = typeof value === "function" ? value(state.clientIds) : value;
@@ -476,13 +1153,12 @@ var hydrateStoreFromDriver = async (store, driver) => {
     rawMints,
     rawInfo,
     rawLastModelsUpdate,
-    rawCachedTokens,
     rawApiKeys,
     rawChildKeys,
+    rawXcashuTokens,
     rawRoutstr21Models,
     rawLastRoutstr21ModelsUpdate,
     rawCachedReceiveTokens,
-    rawUsageTracking,
     rawClientIds
   ] = await Promise.all([
     driver.getItem(
@@ -505,66 +1181,70 @@ var hydrateStoreFromDriver = async (store, driver) => {
       SDK_STORAGE_KEYS.LAST_MODELS_UPDATE,
       {}
     ),
-    driver.getItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, []),
     driver.getItem(SDK_STORAGE_KEYS.API_KEYS, []),
     driver.getItem(SDK_STORAGE_KEYS.CHILD_KEYS, []),
+    driver.getItem(SDK_STORAGE_KEYS.XCASHU_TOKENS, {}),
     driver.getItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, []),
     driver.getItem(
       SDK_STORAGE_KEYS.LAST_ROUTSTR21_MODELS_UPDATE,
       null
     ),
     driver.getItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, []),
-    driver.getItem(SDK_STORAGE_KEYS.USAGE_TRACKING, []),
     driver.getItem(SDK_STORAGE_KEYS.CLIENT_IDS, [])
   ]);
   const modelsFromAllProviders = Object.fromEntries(
     Object.entries(rawModels).map(([baseUrl, models]) => [
-      normalizeBaseUrl(baseUrl),
+      normalizeBaseUrl5(baseUrl),
       models
     ])
   );
-  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl(url));
+  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl5(url));
   const disabledProviders = rawDisabledProviders.map(
-    (url) => normalizeBaseUrl(url)
+    (url) => normalizeBaseUrl5(url)
   );
   const mintsFromAllProviders = Object.fromEntries(
     Object.entries(rawMints).map(([baseUrl, mints]) => [
-      normalizeBaseUrl(baseUrl),
+      normalizeBaseUrl5(baseUrl),
       mints.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
     ])
   );
   const infoFromAllProviders = Object.fromEntries(
     Object.entries(rawInfo).map(([baseUrl, info]) => [
-      normalizeBaseUrl(baseUrl),
+      normalizeBaseUrl5(baseUrl),
       info
     ])
   );
   const lastModelsUpdate = Object.fromEntries(
     Object.entries(rawLastModelsUpdate).map(([baseUrl, timestamp]) => [
-      normalizeBaseUrl(baseUrl),
+      normalizeBaseUrl5(baseUrl),
       timestamp
     ])
   );
-  const cachedTokens = rawCachedTokens.map((entry) => ({
-    ...entry,
-    baseUrl: normalizeBaseUrl(entry.baseUrl),
-    balance: typeof entry.balance === "number" ? entry.balance : getCashuTokenBalance(entry.token),
-    lastUsed: entry.lastUsed ?? null
-  }));
   const apiKeys = rawApiKeys.map((entry) => ({
     ...entry,
-    baseUrl: normalizeBaseUrl(entry.baseUrl),
+    baseUrl: normalizeBaseUrl5(entry.baseUrl),
     balance: entry.balance ?? 0,
     lastUsed: entry.lastUsed ?? null
   }));
   const childKeys = rawChildKeys.map((entry) => ({
-    parentBaseUrl: normalizeBaseUrl(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) => ({
@@ -573,7 +1253,6 @@ var hydrateStoreFromDriver = async (store, driver) => {
     unit: entry.unit || "sat",
     createdAt: entry.createdAt ?? Date.now()
   }));
-  const usageTracking = rawUsageTracking;
   const clientIds = rawClientIds.map((entry) => ({
     ...entry,
     createdAt: entry.createdAt ?? Date.now(),
@@ -588,13 +1267,12 @@ var hydrateStoreFromDriver = async (store, driver) => {
     mintsFromAllProviders,
     infoFromAllProviders,
     lastModelsUpdate,
-    cachedTokens,
     apiKeys,
     childKeys,
+    xcashuTokens,
     routstr21Models,
     lastRoutstr21ModelsUpdate,
     cachedReceiveTokens,
-    usageTracking,
     clientIds
   });
 };
@@ -615,12 +1293,12 @@ var createDiscoveryAdapterFromStore = (store) => ({
   getCachedProviderInfo: () => store.getState().infoFromAllProviders,
   setCachedProviderInfo: (info) => store.getState().setInfoFromAllProviders(info),
   getProviderLastUpdate: (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const timestamps = store.getState().lastModelsUpdate;
     return timestamps[normalized] || null;
   },
   setProviderLastUpdate: (baseUrl, timestamp) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const timestamps = { ...store.getState().lastModelsUpdate };
     timestamps[normalized] = timestamp;
     store.getState().setLastModelsUpdate(timestamps);
@@ -638,59 +1316,6 @@ var createDiscoveryAdapterFromStore = (store) => ({
   setRoutstr21ModelsLastUpdate: (timestamp) => store.getState().setRoutstr21ModelsLastUpdate(timestamp)
 });
 var createStorageAdapterFromStore = (store) => ({
-  getToken: (baseUrl) => {
-    const normalized = normalizeBaseUrl(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 = normalizeBaseUrl(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 = normalizeBaseUrl(baseUrl);
-    const next = store.getState().cachedTokens.filter((entry) => entry.baseUrl !== normalized);
-    store.getState().setCachedTokens(next);
-  },
-  updateTokenBalance: (baseUrl, balance) => {
-    const normalized = normalizeBaseUrl(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 = {};
@@ -703,28 +1328,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 = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const next = { ...store.getState().infoFromAllProviders };
     next[normalized] = info;
     store.getState().setInfoFromAllProviders(next);
   },
   getProviderInfo: (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     return store.getState().infoFromAllProviders[normalized] || null;
   },
   // ========== API Keys (for apikeys mode) ==========
   getApiKey: (baseUrl) => {
-    const normalized = normalizeBaseUrl(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 = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const keys = store.getState().apiKeys;
     const existingIndex = keys.findIndex(
       (entry) => entry.baseUrl === normalized
@@ -742,15 +1363,15 @@ var createStorageAdapterFromStore = (store) => ({
     store.getState().setApiKeys(next);
   },
   updateApiKeyBalance: (baseUrl, balance) => {
-    const normalized = normalizeBaseUrl(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 = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const next = store.getState().apiKeys.filter((entry) => entry.baseUrl !== normalized);
     store.getState().setApiKeys(next);
   },
@@ -764,7 +1385,7 @@ var createStorageAdapterFromStore = (store) => ({
   },
   // ========== Child Keys ==========
   getChildKey: (parentBaseUrl) => {
-    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const normalized = normalizeBaseUrl5(parentBaseUrl);
     const entry = store.getState().childKeys.find((key) => key.parentBaseUrl === normalized);
     if (!entry) return null;
     return {
@@ -777,7 +1398,7 @@ var createStorageAdapterFromStore = (store) => ({
     };
   },
   setChildKey: (parentBaseUrl, childKey, balance, validityDate, balanceLimit) => {
-    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const normalized = normalizeBaseUrl5(parentBaseUrl);
     const keys = store.getState().childKeys;
     const existingIndex = keys.findIndex(
       (entry) => entry.parentBaseUrl === normalized
@@ -808,7 +1429,7 @@ var createStorageAdapterFromStore = (store) => ({
     }
   },
   updateChildKeyBalance: (parentBaseUrl, balance) => {
-    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const normalized = normalizeBaseUrl5(parentBaseUrl);
     const keys = store.getState().childKeys;
     const next = keys.map(
       (entry) => entry.parentBaseUrl === normalized ? { ...entry, balance } : entry
@@ -816,7 +1437,7 @@ var createStorageAdapterFromStore = (store) => ({
     store.getState().setChildKeys(next);
   },
   removeChildKey: (parentBaseUrl) => {
-    const normalized = normalizeBaseUrl(parentBaseUrl);
+    const normalized = normalizeBaseUrl5(parentBaseUrl);
     const next = store.getState().childKeys.filter((entry) => entry.parentBaseUrl !== normalized);
     store.getState().setChildKeys(next);
   },
@@ -835,20 +1456,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 = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     return store.getState().modelsFromAllProviders[normalized] || [];
   },
   getDisabledProviders: () => store.getState().disabledProviders,
   getProviderMints: (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     return store.getState().mintsFromAllProviders[normalized] || [];
   },
   getProviderInfo: async (baseUrl) => {
-    const normalized = normalizeBaseUrl(baseUrl);
+    const normalized = normalizeBaseUrl5(baseUrl);
     const cached = store.getState().infoFromAllProviders[normalized];
     if (cached) return cached;
     try {
@@ -870,7 +1531,7 @@ var createProviderRegistryFromStore = (store) => ({
 });
 
 // storage/index.ts
-var isBrowser2 = () => {
+var isBrowser3 = () => {
   try {
     return typeof window !== "undefined" && typeof window.localStorage !== "undefined";
   } catch {
@@ -885,16 +1546,16 @@ var isNode = () => {
   }
 };
 var defaultDriver = null;
-var isBun2 = () => {
+var isBun3 = () => {
   return typeof process.versions.bun !== "undefined";
 };
 var getDefaultSdkDriver = () => {
   if (defaultDriver) return defaultDriver;
-  if (isBrowser2()) {
+  if (isBrowser3()) {
     defaultDriver = localStorageDriver;
     return defaultDriver;
   }
-  if (isBun2()) {
+  if (isBun3()) {
     defaultDriver = createMemoryDriver();
     return defaultDriver;
   }
@@ -906,29 +1567,62 @@ var getDefaultSdkDriver = () => {
   return defaultDriver;
 };
 var defaultStore = null;
+var defaultUsageTrackingDriver = null;
 var getDefaultSdkStore = () => {
   if (!defaultStore) {
     defaultStore = createSdkStore({ driver: getDefaultSdkDriver() });
   }
   return defaultStore.hydrate.then(() => defaultStore.store);
 };
+var getDefaultUsageTrackingDriver = () => {
+  if (defaultUsageTrackingDriver) return defaultUsageTrackingDriver;
+  const storageDriver = getDefaultSdkDriver();
+  if (isBrowser3()) {
+    defaultUsageTrackingDriver = createIndexedDBUsageTrackingDriver({
+      legacyStorageDriver: storageDriver
+    });
+    return defaultUsageTrackingDriver;
+  }
+  if (isBun3()) {
+    defaultUsageTrackingDriver = createBunSqliteUsageTrackingDriver();
+    return defaultUsageTrackingDriver;
+  }
+  if (isNode()) {
+    defaultUsageTrackingDriver = createSqliteUsageTrackingDriver({
+      legacyStorageDriver: storageDriver
+    });
+    return defaultUsageTrackingDriver;
+  }
+  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());
 
 exports.SDK_STORAGE_KEYS = SDK_STORAGE_KEYS;
+exports.createBunSqliteDriver = createBunSqliteDriver;
+exports.createBunSqliteUsageTrackingDriver = createBunSqliteUsageTrackingDriver;
 exports.createDiscoveryAdapterFromStore = createDiscoveryAdapterFromStore;
 exports.createIndexedDBDriver = createIndexedDBDriver;
+exports.createIndexedDBUsageTrackingDriver = createIndexedDBUsageTrackingDriver;
 exports.createMemoryDriver = createMemoryDriver;
+exports.createMemoryUsageTrackingDriver = createMemoryUsageTrackingDriver;
 exports.createProviderRegistryFromStore = createProviderRegistryFromStore;
 exports.createSdkStore = createSdkStore;
 exports.createSqliteDriver = createSqliteDriver;
+exports.createSqliteUsageTrackingDriver = createSqliteUsageTrackingDriver;
 exports.createStorageAdapterFromStore = createStorageAdapterFromStore;
 exports.getDefaultDiscoveryAdapter = getDefaultDiscoveryAdapter;
 exports.getDefaultProviderRegistry = getDefaultProviderRegistry;
 exports.getDefaultSdkDriver = getDefaultSdkDriver;
 exports.getDefaultSdkStore = getDefaultSdkStore;
 exports.getDefaultStorageAdapter = getDefaultStorageAdapter;
+exports.getDefaultUsageTrackingDriver = getDefaultUsageTrackingDriver;
 exports.localStorageDriver = localStorageDriver;
+exports.setDefaultUsageTrackingDriver = setDefaultUsageTrackingDriver;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map