@routstr/sdk 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,5 +1,8 @@
 'use strict';
 
+var applesauceRelay = require('applesauce-relay');
+var applesauceCore = require('applesauce-core');
+var rxjs = require('rxjs');
 var vanilla = require('zustand/vanilla');
 var cashuTs = require('@cashu/cashu-ts');
 
@@ -99,13 +102,11 @@ var MintDiscoveryError = class extends Error {
     this.name = "MintDiscoveryError";
   }
 };
-
-// discovery/ModelManager.ts
 var ModelManager = class _ModelManager {
   constructor(adapter, config = {}) {
     this.adapter = adapter;
     this.providerDirectoryUrl = config.providerDirectoryUrl || "https://api.routstr.com/v1/providers/";
-    this.cacheTTL = config.cacheTTL || 21 * 60 * 1e3;
+    this.cacheTTL = config.cacheTTL || 210 * 60 * 1e3;
     this.includeProviderUrls = config.includeProviderUrls || [];
     this.excludeProviderUrls = config.excludeProviderUrls || [];
   }
@@ -130,21 +131,132 @@ var ModelManager = class _ModelManager {
   }
   /**
    * Bootstrap provider list from the provider directory
-   * Fetches available providers and caches their base URLs
+   * First tries to fetch from Nostr (kind 30421), falls back to HTTP
    * @param torMode Whether running in Tor context
    * @returns Array of provider base URLs
    * @throws ProviderBootstrapError if all providers fail to fetch
    */
   async bootstrapProviders(torMode = false) {
+    const cachedUrls = this.adapter.getBaseUrlsList();
+    if (cachedUrls.length > 0) {
+      const lastUpdate = this.adapter.getBaseUrlsLastUpdate();
+      const cacheValid = lastUpdate && Date.now() - lastUpdate <= this.cacheTTL;
+      if (cacheValid) {
+        return this.filterBaseUrlsForTor(cachedUrls, torMode);
+      }
+    }
     try {
-      const cachedUrls = this.adapter.getBaseUrlsList();
-      if (cachedUrls.length > 0) {
-        const lastUpdate = this.adapter.getBaseUrlsLastUpdate();
-        const cacheValid = lastUpdate && Date.now() - lastUpdate <= this.cacheTTL;
-        if (cacheValid) {
-          return this.filterBaseUrlsForTor(cachedUrls, torMode);
+      const nostrProviders = await this.bootstrapFromNostr(38421, torMode);
+      if (nostrProviders.length > 0) {
+        const filtered = this.filterBaseUrlsForTor(nostrProviders, torMode);
+        this.adapter.setBaseUrlsList(filtered);
+        this.adapter.setBaseUrlsLastUpdate(Date.now());
+        await this.fetchRoutstr21Models();
+        return filtered;
+      }
+    } catch (e) {
+      console.warn("Nostr bootstrap failed, falling back to HTTP:", e);
+    }
+    return this.bootstrapFromHttp(torMode);
+  }
+  /**
+   * Bootstrap providers from Nostr network (kind 30421)
+   * @param kind The Nostr kind to fetch
+   * @param torMode Whether running in Tor context
+   * @returns Array of provider base URLs
+   */
+  async bootstrapFromNostr(kind, torMode) {
+    const DEFAULT_RELAYS = [
+      "wss://relay.primal.net",
+      "wss://nos.lol",
+      "wss://relay.routstr.com"
+    ];
+    const pool = new applesauceRelay.RelayPool();
+    const localEventStore = new applesauceCore.EventStore();
+    const timeoutMs = 5e3;
+    await new Promise((resolve) => {
+      pool.req(DEFAULT_RELAYS, {
+        kinds: [kind],
+        limit: 100
+      }).pipe(
+        applesauceRelay.onlyEvents(),
+        rxjs.tap((event) => {
+          localEventStore.add(event);
+        })
+      ).subscribe({
+        complete: () => {
+          resolve();
+        }
+      });
+      setTimeout(() => {
+        resolve();
+      }, timeoutMs);
+    });
+    const timeline = localEventStore.getTimeline({ kinds: [kind] });
+    const bases = /* @__PURE__ */ new Set();
+    for (const event of timeline) {
+      const eventUrls = [];
+      for (const tag of event.tags) {
+        if (tag[0] === "u" && typeof tag[1] === "string") {
+          eventUrls.push(tag[1]);
+        }
+      }
+      if (eventUrls.length > 0) {
+        for (const url of eventUrls) {
+          const normalized = this.normalizeUrl(url);
+          if (!torMode || normalized.includes(".onion")) {
+            bases.add(normalized);
+          }
+        }
+        continue;
+      }
+      try {
+        const content = JSON.parse(event.content);
+        const providers = Array.isArray(content) ? content : content.providers || [];
+        for (const p of providers) {
+          const endpoints = this.getProviderEndpoints(p, torMode);
+          for (const endpoint of endpoints) {
+            bases.add(endpoint);
+          }
+        }
+      } catch {
+        try {
+          const providers = JSON.parse(event.content);
+          if (Array.isArray(providers)) {
+            for (const p of providers) {
+              const endpoints = this.getProviderEndpoints(p, torMode);
+              for (const endpoint of endpoints) {
+                bases.add(endpoint);
+              }
+            }
+          }
+        } catch {
+          console.warn(
+            "[NostrBootstrap] Failed to parse Nostr event content:",
+            event.id
+          );
         }
       }
+    }
+    for (const url of this.includeProviderUrls) {
+      const normalized = this.normalizeUrl(url);
+      if (!torMode || normalized.includes(".onion")) {
+        bases.add(normalized);
+      }
+    }
+    const excluded = new Set(
+      this.excludeProviderUrls.map((url) => this.normalizeUrl(url))
+    );
+    const result = Array.from(bases).filter((base) => !excluded.has(base));
+    return result;
+  }
+  /**
+   * Bootstrap providers from HTTP endpoint
+   * @param torMode Whether running in Tor context
+   * @returns Array of provider base URLs
+   */
+  async bootstrapFromHttp(torMode) {
+    try {
       const res = await fetch(this.providerDirectoryUrl);
       if (!res.ok) {
         throw new Error(`Failed to fetch providers: ${res.status}`);
@@ -167,13 +279,11 @@ var ModelManager = class _ModelManager {
       const excluded = new Set(
         this.excludeProviderUrls.map((url) => this.normalizeUrl(url))
       );
-      const list = Array.from(bases).filter((base) => {
-        if (excluded.has(base)) return false;
-        return true;
-      });
+      const list = Array.from(bases).filter((base) => !excluded.has(base));
       if (list.length > 0) {
         this.adapter.setBaseUrlsList(list);
         this.adapter.setBaseUrlsLastUpdate(Date.now());
+        await this.fetchRoutstr21Models();
       }
       return list;
     } catch (e) {
@@ -340,6 +450,57 @@ var ModelManager = class _ModelManager {
     }
     return url.endsWith("/") ? url : `${url}/`;
   }
+  /**
+   * Fetch routstr21 models from Nostr network (kind 38423)
+   * @returns Array of model IDs or empty array if not found
+   */
+  async fetchRoutstr21Models() {
+    const DEFAULT_RELAYS = [
+      "wss://relay.primal.net",
+      "wss://nos.lol",
+      "wss://relay.routstr.com"
+    ];
+    const pool = new applesauceRelay.RelayPool();
+    const localEventStore = new applesauceCore.EventStore();
+    const timeoutMs = 5e3;
+    await new Promise((resolve) => {
+      pool.req(DEFAULT_RELAYS, {
+        kinds: [38423],
+        "#d": ["routstr-21-models"],
+        limit: 1,
+        authors: ["4ad6fa2d16e2a9b576c863b4cf7404a70d4dc320c0c447d10ad6ff58993eacc8"]
+      }).pipe(
+        applesauceRelay.onlyEvents(),
+        rxjs.tap((event2) => {
+          localEventStore.add(event2);
+        })
+      ).subscribe({
+        complete: () => {
+          resolve();
+        }
+      });
+      setTimeout(() => {
+        resolve();
+      }, timeoutMs);
+    });
+    const timeline = localEventStore.getTimeline({ kinds: [38423] });
+    if (timeline.length === 0) {
+      return [];
+    }
+    const event = timeline[0];
+    try {
+      const content = JSON.parse(event.content);
+      const models = Array.isArray(content?.models) ? content.models : [];
+      this.adapter.setRoutstr21Models(models);
+      return models;
+    } catch {
+      console.warn(
+        "[Routstr21Models] Failed to parse Nostr event content:",
+        event.id
+      );
+      return [];
+    }
+  }
 };
 
 // discovery/MintDiscovery.ts
@@ -540,15 +701,55 @@ var AuditLogger = class _AuditLogger {
 };
 var auditLogger = AuditLogger.getInstance();
 
+// wallet/tokenUtils.ts
+function isNetworkErrorMessage(message) {
+  return message.includes("NetworkError when attempting to fetch resource") || message.includes("Failed to fetch") || message.includes("Load failed");
+}
+function getBalanceInSats(balance, unit) {
+  return unit === "msat" ? balance / 1e3 : balance;
+}
+function selectMintWithBalance(balances, units, amount, excludeMints = []) {
+  for (const mintUrl in balances) {
+    if (excludeMints.includes(mintUrl)) {
+      continue;
+    }
+    const balanceInSats = getBalanceInSats(balances[mintUrl], units[mintUrl]);
+    if (balanceInSats >= amount) {
+      return { selectedMintUrl: mintUrl, selectedMintBalance: balanceInSats };
+    }
+  }
+  return { selectedMintUrl: null, selectedMintBalance: 0 };
+}
+
 // wallet/CashuSpender.ts
 var CashuSpender = class {
-  constructor(walletAdapter, storageAdapter, providerRegistry, balanceManager) {
+  constructor(walletAdapter, storageAdapter, _providerRegistry, balanceManager) {
     this.walletAdapter = walletAdapter;
     this.storageAdapter = storageAdapter;
-    this.providerRegistry = providerRegistry;
+    this._providerRegistry = _providerRegistry;
     this.balanceManager = balanceManager;
   }
   _isBusy = false;
+  debugLevel = "WARN";
+  async receiveToken(token) {
+    const result = await this.walletAdapter.receiveToken(token);
+    if (!result.success && result.message?.includes("Failed to fetch mint")) {
+      const cachedTokens = this.storageAdapter.getCachedReceiveTokens();
+      const existingIndex = cachedTokens.findIndex((t) => t.token === token);
+      if (existingIndex === -1) {
+        this.storageAdapter.setCachedReceiveTokens([
+          ...cachedTokens,
+          {
+            token,
+            amount: result.amount,
+            unit: result.unit,
+            createdAt: Date.now()
+          }
+        ]);
+      }
+    }
+    return result;
+  }
   async _getBalanceState() {
     const mintBalances = await this.walletAdapter.getBalances();
     const units = this.walletAdapter.getMintUnits();
@@ -557,11 +758,11 @@ var CashuSpender = class {
     for (const url in mintBalances) {
       const balance = mintBalances[url];
       const unit = units[url];
-      const balanceInSats = unit === "msat" ? balance / 1e3 : balance;
+      const balanceInSats = getBalanceInSats(balance, unit);
       normalizedMintBalances[url] = balanceInSats;
       totalMintBalance += balanceInSats;
     }
-    const pendingDistribution = this.storageAdapter.getPendingTokenDistribution();
+    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
     const providerBalances = {};
     let totalProviderBalance = 0;
     for (const pending of pendingDistribution) {
@@ -591,8 +792,35 @@ var CashuSpender = class {
   get isBusy() {
     return this._isBusy;
   }
+  getDebugLevel() {
+    return this.debugLevel;
+  }
+  setDebugLevel(level) {
+    this.debugLevel = level;
+  }
+  _log(level, ...args) {
+    const levelPriority = {
+      DEBUG: 0,
+      WARN: 1,
+      ERROR: 2
+    };
+    if (levelPriority[level] >= levelPriority[this.debugLevel]) {
+      switch (level) {
+        case "DEBUG":
+          console.log(...args);
+          break;
+        case "WARN":
+          console.warn(...args);
+          break;
+        case "ERROR":
+          console.error(...args);
+          break;
+      }
+    }
+  }
   /**
    * Spend Cashu tokens with automatic mint selection and retry logic
+   * Throws errors on failure instead of returning failed SpendResult
    */
   async spend(options) {
     const {
@@ -606,7 +834,7 @@ var CashuSpender = class {
     } = options;
     this._isBusy = true;
     try {
-      return await this._spendInternal({
+      const result = await this._spendInternal({
         mintUrl,
         amount,
         baseUrl,
@@ -615,10 +843,34 @@ var CashuSpender = class {
         excludeMints,
         retryCount
       });
+      if (result.status === "failed" || !result.token) {
+        const errorMsg = result.error || `Insufficient balance. Need ${amount} sats.`;
+        if (this._isNetworkError(errorMsg)) {
+          throw new Error(
+            `Your mint ${mintUrl} is unreachable or is blocking your IP. Please try again later or switch mints.`
+          );
+        }
+        if (result.errorDetails) {
+          throw new InsufficientBalanceError(
+            result.errorDetails.required,
+            result.errorDetails.available,
+            result.errorDetails.maxMintBalance,
+            result.errorDetails.maxMintUrl
+          );
+        }
+        throw new Error(errorMsg);
+      }
+      return result;
     } finally {
       this._isBusy = false;
     }
   }
+  /**
+   * Check if error message indicates a network error
+   */
+  _isNetworkError(message) {
+    return isNetworkErrorMessage(message) || message.includes("Your mint") && message.includes("unreachable");
+  }
   /**
    * Internal spending logic
    */
@@ -632,8 +884,16 @@ var CashuSpender = class {
       excludeMints,
       retryCount
     } = options;
+    this._log(
+      "DEBUG",
+      `[CashuSpender] _spendInternal: amount=${amount}, mintUrl=${mintUrl}, baseUrl=${baseUrl}, reuseToken=${reuseToken}`
+    );
     let adjustedAmount = Math.ceil(amount);
     if (!adjustedAmount || isNaN(adjustedAmount)) {
+      this._log(
+        "ERROR",
+        `[CashuSpender] _spendInternal: Invalid amount: ${amount}`
+      );
       return {
         token: null,
         status: "failed",
@@ -642,14 +902,26 @@ var CashuSpender = class {
       };
     }
     if (reuseToken && baseUrl) {
+      this._log(
+        "DEBUG",
+        `[CashuSpender] _spendInternal: Attempting to reuse token for ${baseUrl}`
+      );
       const existingResult = await this._tryReuseToken(
         baseUrl,
         adjustedAmount,
         mintUrl
       );
       if (existingResult) {
+        this._log(
+          "DEBUG",
+          `[CashuSpender] _spendInternal: Successfully reused token, balance: ${existingResult.balance}`
+        );
         return existingResult;
       }
+      this._log(
+        "DEBUG",
+        `[CashuSpender] _spendInternal: Could not reuse token, will create new token`
+      );
     }
     const balances = await this.walletAdapter.getBalances();
     const units = this.walletAdapter.getMintUnits();
@@ -657,19 +929,24 @@ var CashuSpender = class {
     for (const url in balances) {
       const balance = balances[url];
       const unit = units[url];
-      const balanceInSats = unit === "msat" ? balance / 1e3 : balance;
+      const balanceInSats = getBalanceInSats(balance, unit);
       totalBalance += balanceInSats;
     }
-    const pendingDistribution = this.storageAdapter.getPendingTokenDistribution();
+    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
     const totalPending = pendingDistribution.reduce(
       (sum, item) => sum + item.amount,
       0
     );
-    if (totalBalance < adjustedAmount && totalPending + totalBalance > adjustedAmount && (retryCount ?? 0) < 1) {
-      return await this._refundAndRetry(options);
-    }
+    this._log(
+      "DEBUG",
+      `[CashuSpender] _spendInternal: totalBalance=${totalBalance}, totalPending=${totalPending}, adjustedAmount=${adjustedAmount}`
+    );
     const totalAvailableBalance = totalBalance + totalPending;
     if (totalAvailableBalance < adjustedAmount) {
+      this._log(
+        "ERROR",
+        `[CashuSpender] _spendInternal: Insufficient balance, have=${totalAvailableBalance}, need=${adjustedAmount}`
+      );
       return this._createInsufficientBalanceError(
         adjustedAmount,
         balances,
@@ -677,72 +954,73 @@ var CashuSpender = class {
         totalAvailableBalance
       );
     }
-    let { selectedMintUrl, selectedMintBalance } = this._selectMintWithBalance(
-      balances,
-      units,
-      adjustedAmount,
-      excludeMints
-    );
-    if (selectedMintUrl && baseUrl && this.providerRegistry) {
-      const providerMints = this.providerRegistry.getProviderMints(baseUrl);
-      if (providerMints.length > 0 && !providerMints.includes(selectedMintUrl)) {
-        const alternateResult = await this._findAlternateMint(
-          options,
-          balances,
-          units,
-          providerMints
-        );
-        if (alternateResult) {
-          return alternateResult;
+    let token = null;
+    let selectedMintUrl;
+    let spentAmount = adjustedAmount;
+    if (this.balanceManager) {
+      const tokenResult = await this.balanceManager.createProviderToken({
+        mintUrl,
+        baseUrl,
+        amount: adjustedAmount,
+        p2pkPubkey,
+        excludeMints,
+        retryCount
+      });
+      if (!tokenResult.success || !tokenResult.token) {
+        if ((tokenResult.error || "").includes("Insufficient balance")) {
+          return this._createInsufficientBalanceError(
+            adjustedAmount,
+            balances,
+            units,
+            totalAvailableBalance
+          );
         }
-        adjustedAmount += 2;
+        return {
+          token: null,
+          status: "failed",
+          balance: 0,
+          error: tokenResult.error || "Failed to create token"
+        };
       }
-    }
-    const activeMintBalance = balances[mintUrl] || 0;
-    const activeMintUnit = units[mintUrl];
-    const activeMintBalanceInSats = activeMintUnit === "msat" ? activeMintBalance / 1e3 : activeMintBalance;
-    let token = null;
-    if (activeMintBalanceInSats >= adjustedAmount && (baseUrl === "" || !this.providerRegistry)) {
+      token = tokenResult.token;
+      selectedMintUrl = tokenResult.selectedMintUrl;
+      spentAmount = tokenResult.amountSpent || adjustedAmount;
+    } else {
       try {
         token = await this.walletAdapter.sendToken(
           mintUrl,
           adjustedAmount,
           p2pkPubkey
         );
+        selectedMintUrl = mintUrl;
       } catch (error) {
-        return this._handleSendError(error, options, balances, units);
-      }
-    } else if (selectedMintUrl && selectedMintBalance >= adjustedAmount) {
-      try {
-        token = await this.walletAdapter.sendToken(
-          selectedMintUrl,
-          adjustedAmount,
-          p2pkPubkey
-        );
-      } catch (error) {
-        return this._handleSendError(error, options, balances, units);
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        return {
+          token: null,
+          status: "failed",
+          balance: 0,
+          error: `Error generating token: ${errorMsg}`
+        };
       }
-    } else {
-      return this._createInsufficientBalanceError(
-        adjustedAmount,
-        balances,
-        units
-      );
     }
     if (token && baseUrl) {
       this.storageAdapter.setToken(baseUrl, token);
     }
     this._logTransaction("spend", {
-      amount: adjustedAmount,
+      amount: spentAmount,
       mintUrl: selectedMintUrl || mintUrl,
       baseUrl,
       status: "success"
     });
+    this._log(
+      "DEBUG",
+      `[CashuSpender] _spendInternal: Successfully spent ${spentAmount}, returning token with balance=${spentAmount}`
+    );
     return {
       token,
       status: "success",
-      balance: adjustedAmount,
-      unit: activeMintUnit
+      balance: spentAmount,
+      unit: (selectedMintUrl ? units[selectedMintUrl] : units[mintUrl]) || "sat"
     };
   }
   /**
@@ -751,9 +1029,9 @@ var CashuSpender = class {
   async _tryReuseToken(baseUrl, amount, mintUrl) {
     const storedToken = this.storageAdapter.getToken(baseUrl);
     if (!storedToken) return null;
-    const pendingDistribution = this.storageAdapter.getPendingTokenDistribution();
+    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
     const balanceForBaseUrl = pendingDistribution.find((b) => b.baseUrl === baseUrl)?.amount || 0;
-    console.log("RESUINGDSR GSODGNSD", balanceForBaseUrl, amount);
+    this._log("DEBUG", "RESUINGDSR GSODGNSD", balanceForBaseUrl, amount);
     if (balanceForBaseUrl > amount) {
       const units = this.walletAdapter.getMintUnits();
       const unit = units[mintUrl] || "sat";
@@ -771,7 +1049,7 @@ var CashuSpender = class {
         baseUrl,
         amount: topUpAmount
       });
-      console.log("TOPUP ", topUpResult);
+      this._log("DEBUG", "TOPUP ", topUpResult);
       if (topUpResult.success && topUpResult.toppedUpAmount) {
         const newBalance = balanceForBaseUrl + topUpResult.toppedUpAmount;
         const units = this.walletAdapter.getMintUnits();
@@ -793,7 +1071,7 @@ var CashuSpender = class {
         baseUrl,
         storedToken
       );
-      console.log(providerBalance);
+      this._log("DEBUG", providerBalance);
       if (providerBalance <= 0) {
         this.storageAdapter.removeToken(baseUrl);
       }
@@ -801,18 +1079,25 @@ var CashuSpender = class {
     return null;
   }
   /**
-   * Refund pending tokens and retry
+   * Refund specific providers without retrying spend
    */
-  async _refundAndRetry(options) {
-    const { mintUrl, baseUrl, retryCount } = options;
-    const pendingDistribution = this.storageAdapter.getPendingTokenDistribution();
+  async refundProviders(baseUrls, mintUrl, refundApiKeys = false) {
+    const results = [];
+    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
+    const toRefund = pendingDistribution.filter(
+      (p) => baseUrls.includes(p.baseUrl)
+    );
     const refundResults = await Promise.allSettled(
-      pendingDistribution.map(async (pending) => {
+      toRefund.map(async (pending) => {
         const token = this.storageAdapter.getToken(pending.baseUrl);
-        if (!token || !this.balanceManager || pending.baseUrl === 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);
+        const tokenBalance = await this.balanceManager.getTokenBalance(
+          token,
+          pending.baseUrl
+        );
         if (tokenBalance.reserved > 0) {
           return { baseUrl: pending.baseUrl, success: false };
         }
@@ -821,120 +1106,49 @@ var CashuSpender = class {
           baseUrl: pending.baseUrl,
           token
         });
+        this._log("DEBUG", result);
+        if (result.success) {
+          this.storageAdapter.removeToken(pending.baseUrl);
+        }
         return { baseUrl: pending.baseUrl, success: result.success };
       })
     );
-    for (const result of refundResults) {
-      const refundResult = result.status === "fulfilled" ? result.value : { baseUrl: "", success: false };
-      if (refundResult.success) {
-        this.storageAdapter.removeToken(refundResult.baseUrl);
-      }
-    }
-    const successfulRefunds = refundResults.filter(
-      (r) => r.status === "fulfilled" && r.value.success
-    ).length;
-    if (successfulRefunds > 0) {
-      this._logTransaction("refund", {
-        amount: pendingDistribution.length,
-        mintUrl,
-        status: "success",
-        details: `Refunded ${successfulRefunds} of ${pendingDistribution.length} tokens`
-      });
-    }
-    return this._spendInternal({
-      ...options,
-      retryCount: (retryCount || 0) + 1
-    });
-  }
-  /**
-   * Find an alternate mint that the provider accepts
-   */
-  async _findAlternateMint(options, balances, units, providerMints) {
-    const { amount, excludeMints } = options;
-    const adjustedAmount = Math.ceil(amount) + 2;
-    const extendedExcludes = [...excludeMints || []];
-    while (true) {
-      const { selectedMintUrl } = this._selectMintWithBalance(
-        balances,
-        units,
-        adjustedAmount,
-        extendedExcludes
+    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)
       );
-      if (!selectedMintUrl) break;
-      if (providerMints.includes(selectedMintUrl)) {
-        try {
-          const token = await this.walletAdapter.sendToken(
-            selectedMintUrl,
-            adjustedAmount
-          );
-          if (options.baseUrl) {
-            this.storageAdapter.setToken(options.baseUrl, token);
+      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
+          });
+          if (refundResult.success) {
+            this.storageAdapter.updateApiKeyBalance(apiKeyEntry.baseUrl, 0);
           }
-          return {
-            token,
-            status: "success",
-            balance: adjustedAmount,
-            unit: units[selectedMintUrl] || "sat"
-          };
-        } catch (error) {
-          extendedExcludes.push(selectedMintUrl);
+          results.push({
+            baseUrl: apiKeyEntry.baseUrl,
+            success: refundResult.success
+          });
+        } else {
+          results.push({
+            baseUrl: apiKeyEntry.baseUrl,
+            success: false
+          });
         }
-      } else {
-        extendedExcludes.push(selectedMintUrl);
-      }
-    }
-    return null;
-  }
-  /**
-   * Handle send errors with retry logic for network errors
-   */
-  async _handleSendError(error, options, balances, units) {
-    const errorMsg = error instanceof Error ? error.message : String(error);
-    const isNetworkError = error instanceof Error && (error.message.includes(
-      "NetworkError when attempting to fetch resource"
-    ) || error.message.includes("Failed to fetch") || error.message.includes("Load failed"));
-    if (isNetworkError) {
-      const { mintUrl, amount, baseUrl, p2pkPubkey, excludeMints, retryCount } = options;
-      const extendedExcludes = [...excludeMints || [], mintUrl];
-      const { selectedMintUrl } = this._selectMintWithBalance(
-        balances,
-        units,
-        Math.ceil(amount),
-        extendedExcludes
-      );
-      if (selectedMintUrl && (retryCount || 0) < Object.keys(balances).length) {
-        return this._spendInternal({
-          ...options,
-          mintUrl: selectedMintUrl,
-          excludeMints: extendedExcludes,
-          retryCount: (retryCount || 0) + 1
-        });
       }
-      throw new MintUnreachableError(mintUrl);
     }
-    return {
-      token: null,
-      status: "failed",
-      balance: 0,
-      error: `Error generating token: ${errorMsg}`
-    };
-  }
-  /**
-   * Select a mint with sufficient balance
-   */
-  _selectMintWithBalance(balances, units, amount, excludeMints = []) {
-    for (const mintUrl in balances) {
-      if (excludeMints.includes(mintUrl)) {
-        continue;
-      }
-      const balance = balances[mintUrl];
-      const unit = units[mintUrl];
-      const balanceInSats = unit === "msat" ? balance / 1e3 : balance;
-      if (balanceInSats >= amount) {
-        return { selectedMintUrl: mintUrl, selectedMintBalance: balanceInSats };
-      }
-    }
-    return { selectedMintUrl: null, selectedMintBalance: 0 };
+    return results;
   }
   /**
    * Create an insufficient balance error result
@@ -945,7 +1159,7 @@ var CashuSpender = class {
     for (const mintUrl in balances) {
       const balance = balances[mintUrl];
       const unit = units[mintUrl];
-      const balanceInSats = unit === "msat" ? balance / 1e3 : balance;
+      const balanceInSats = getBalanceInSats(balance, unit);
       if (balanceInSats > maxBalance) {
         maxBalance = balanceInSats;
         maxMintUrl = mintUrl;
@@ -990,10 +1204,22 @@ var CashuSpender = class {
 
 // wallet/BalanceManager.ts
 var BalanceManager = class {
-  constructor(walletAdapter, storageAdapter) {
+  constructor(walletAdapter, storageAdapter, providerRegistry, cashuSpender) {
     this.walletAdapter = walletAdapter;
     this.storageAdapter = storageAdapter;
+    this.providerRegistry = providerRegistry;
+    if (cashuSpender) {
+      this.cashuSpender = cashuSpender;
+    } else {
+      this.cashuSpender = new CashuSpender(
+        walletAdapter,
+        storageAdapter,
+        providerRegistry,
+        this
+      );
+    }
   }
+  cashuSpender;
   /**
    * Unified refund - handles both NIP-60 and legacy wallet refunds
    */
@@ -1028,7 +1254,7 @@ var BalanceManager = class {
         this.storageAdapter.removeToken(baseUrl);
         return { success: true, message: "No balance to refund" };
       }
-      const receiveResult = await this.walletAdapter.receiveToken(
+      const receiveResult = await this.cashuSpender.receiveToken(
         fetchResult.token
       );
       const totalAmountMsat = receiveResult.unit === "msat" ? receiveResult.amount : receiveResult.amount * 1e3;
@@ -1046,52 +1272,51 @@ var BalanceManager = class {
     }
   }
   /**
-   * Top up API key balance with a cashu token
+   * Refund API key balance - convert remaining API key balance to cashu token
    */
-  async topUp(options) {
-    const { mintUrl, baseUrl, amount, token: providedToken } = options;
-    if (!amount || amount <= 0) {
-      return { success: false, message: "Invalid top up amount" };
-    }
-    const storedToken = providedToken || this.storageAdapter.getToken(baseUrl);
-    if (!storedToken) {
-      return { success: false, message: "No API key available for top up" };
+  async refundApiKey(options) {
+    const { mintUrl, baseUrl, apiKey } = options;
+    if (!apiKey) {
+      return { success: false, message: "No API key to refund" };
     }
-    let cashuToken = null;
-    let requestId;
+    let fetchResult;
     try {
-      cashuToken = await this.walletAdapter.sendToken(mintUrl, amount);
-      const topUpResult = await this._postTopUp(
-        baseUrl,
-        storedToken,
-        cashuToken
-      );
-      requestId = topUpResult.requestId;
-      if (!topUpResult.success) {
-        await this._recoverFailedTopUp(cashuToken);
+      fetchResult = await this._fetchRefundTokenWithApiKey(baseUrl, apiKey);
+      if (!fetchResult.success) {
         return {
           success: false,
-          message: topUpResult.error || "Top up failed",
-          requestId,
-          recoveredToken: true
+          message: fetchResult.error || "API key refund failed",
+          requestId: fetchResult.requestId
+        };
+      }
+      if (!fetchResult.token) {
+        return {
+          success: false,
+          message: "No token received from API key refund",
+          requestId: fetchResult.requestId
         };
       }
+      if (fetchResult.error === "No balance to refund") {
+        return { success: false, message: "No balance to refund" };
+      }
+      const receiveResult = await this.cashuSpender.receiveToken(
+        fetchResult.token
+      );
+      const totalAmountMsat = receiveResult.unit === "msat" ? receiveResult.amount : receiveResult.amount * 1e3;
       return {
-        success: true,
-        toppedUpAmount: amount,
-        requestId
+        success: receiveResult.success,
+        refundedAmount: totalAmountMsat,
+        requestId: fetchResult.requestId
       };
     } catch (error) {
-      if (cashuToken) {
-        await this._recoverFailedTopUp(cashuToken);
-      }
-      return this._handleTopUpError(error, mintUrl, requestId);
+      console.error("[BalanceManager] API key refund error", error);
+      return this._handleRefundError(error, mintUrl, fetchResult?.requestId);
     }
   }
   /**
-   * Fetch refund token from provider API
+   * Fetch refund token from provider API using API key authentication
    */
-  async _fetchRefundToken(baseUrl, storedToken) {
+  async _fetchRefundTokenWithApiKey(baseUrl, apiKey) {
     if (!baseUrl) {
       return {
         success: false,
@@ -1108,7 +1333,7 @@ var BalanceManager = class {
       const response = await fetch(url, {
         method: "POST",
         headers: {
-          Authorization: `Bearer ${storedToken}`,
+          Authorization: `Bearer ${apiKey}`,
           "Content-Type": "application/json"
         },
         signal: controller.signal
@@ -1117,22 +1342,314 @@ var BalanceManager = class {
       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}`
+          error: `API key refund failed: ${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._fetchRefundTokenWithApiKey] 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 API key refund request"
+      };
+    }
+  }
+  /**
+   * Top up API key balance with a cashu token
+   */
+  async topUp(options) {
+    const { mintUrl, baseUrl, amount, token: providedToken } = options;
+    if (!amount || amount <= 0) {
+      return { success: false, message: "Invalid top up amount" };
+    }
+    const storedToken = providedToken || this.storageAdapter.getToken(baseUrl);
+    if (!storedToken) {
+      return { success: false, message: "No API key available for top up" };
+    }
+    let cashuToken = null;
+    let requestId;
+    try {
+      const tokenResult = await this.createProviderToken({
+        mintUrl,
+        baseUrl,
+        amount
+      });
+      if (!tokenResult.success || !tokenResult.token) {
+        return {
+          success: false,
+          message: tokenResult.error || "Unable to create top up token"
+        };
+      }
+      cashuToken = tokenResult.token;
+      const topUpResult = await this._postTopUp(
+        baseUrl,
+        storedToken,
+        cashuToken
+      );
+      requestId = topUpResult.requestId;
+      console.log(topUpResult);
+      if (!topUpResult.success) {
+        await this._recoverFailedTopUp(cashuToken);
+        return {
+          success: false,
+          message: topUpResult.error || "Top up failed",
+          requestId,
+          recoveredToken: true
+        };
+      }
+      return {
+        success: true,
+        toppedUpAmount: amount,
+        requestId
+      };
+    } catch (error) {
+      if (cashuToken) {
+        await this._recoverFailedTopUp(cashuToken);
+      }
+      return this._handleTopUpError(error, mintUrl, requestId);
+    }
+  }
+  async createProviderToken(options) {
+    const {
+      mintUrl,
+      baseUrl,
+      amount,
+      retryCount = 0,
+      excludeMints = [],
+      p2pkPubkey
+    } = options;
+    const adjustedAmount = Math.ceil(amount);
+    if (!adjustedAmount || isNaN(adjustedAmount)) {
+      return { success: false, error: "Invalid top up amount" };
+    }
+    const balances = await this.walletAdapter.getBalances();
+    const units = this.walletAdapter.getMintUnits();
+    let totalMintBalance = 0;
+    for (const url in balances) {
+      const unit = units[url];
+      const balanceInSats = getBalanceInSats(balances[url], unit);
+      totalMintBalance += balanceInSats;
+    }
+    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
+    const refundablePending = pendingDistribution.filter((entry) => entry.baseUrl !== baseUrl).reduce((sum, entry) => sum + entry.amount, 0);
+    if (totalMintBalance < adjustedAmount && totalMintBalance + refundablePending >= adjustedAmount && retryCount < 1) {
+      await this._refundOtherProvidersForTopUp(baseUrl, mintUrl);
+      return this.createProviderToken({
+        ...options,
+        retryCount: retryCount + 1
+      });
+    }
+    const providerMints = baseUrl && this.providerRegistry ? this.providerRegistry.getProviderMints(baseUrl) : [];
+    let requiredAmount = adjustedAmount;
+    const supportedMintsOnly = providerMints.length > 0;
+    let candidates = this._selectCandidateMints({
+      balances,
+      units,
+      amount: requiredAmount,
+      preferredMintUrl: mintUrl,
+      excludeMints,
+      allowedMints: supportedMintsOnly ? providerMints : void 0
+    });
+    if (candidates.length === 0 && supportedMintsOnly) {
+      requiredAmount += 2;
+      candidates = this._selectCandidateMints({
+        balances,
+        units,
+        amount: requiredAmount,
+        preferredMintUrl: mintUrl,
+        excludeMints
+      });
+    }
+    if (candidates.length === 0) {
+      let maxBalance = 0;
+      let maxMintUrl = "";
+      for (const mintUrl2 in balances) {
+        const balance = balances[mintUrl2];
+        const unit = units[mintUrl2];
+        const balanceInSats = getBalanceInSats(balance, unit);
+        if (balanceInSats > maxBalance) {
+          maxBalance = balanceInSats;
+          maxMintUrl = mintUrl2;
+        }
+      }
+      const error = new InsufficientBalanceError(
+        adjustedAmount,
+        totalMintBalance,
+        maxBalance,
+        maxMintUrl
+      );
+      return { success: false, error: error.message };
+    }
+    let lastError;
+    for (const candidateMint of candidates) {
+      try {
+        const token = await this.walletAdapter.sendToken(
+          candidateMint,
+          requiredAmount,
+          p2pkPubkey
+        );
+        return {
+          success: true,
+          token,
+          selectedMintUrl: candidateMint,
+          amountSpent: requiredAmount
+        };
+      } catch (error) {
+        if (error instanceof Error) {
+          lastError = error.message;
+          if (isNetworkErrorMessage(error.message)) {
+            continue;
+          }
+        }
+        return {
+          success: false,
+          error: lastError || "Failed to create top up token"
+        };
+      }
+    }
+    return {
+      success: false,
+      error: lastError || "All candidate mints failed while creating top up token"
+    };
+  }
+  _selectCandidateMints(options) {
+    const {
+      balances,
+      units,
+      amount,
+      preferredMintUrl,
+      excludeMints,
+      allowedMints
+    } = options;
+    const candidates = [];
+    const { selectedMintUrl: firstMint } = selectMintWithBalance(
+      balances,
+      units,
+      amount,
+      excludeMints
+    );
+    if (firstMint && (!allowedMints || allowedMints.length === 0 || allowedMints.includes(firstMint))) {
+      candidates.push(firstMint);
+    }
+    const canUseMint = (mint) => {
+      if (excludeMints.includes(mint)) return false;
+      if (allowedMints && allowedMints.length > 0 && !allowedMints.includes(mint)) {
+        return false;
+      }
+      const rawBalance = balances[mint] || 0;
+      const unit = units[mint];
+      const balanceInSats = getBalanceInSats(rawBalance, unit);
+      return balanceInSats >= amount;
+    };
+    if (preferredMintUrl && canUseMint(preferredMintUrl) && !candidates.includes(preferredMintUrl)) {
+      candidates.push(preferredMintUrl);
+    }
+    for (const mint in balances) {
+      if (mint === preferredMintUrl || candidates.includes(mint)) continue;
+      if (canUseMint(mint)) {
+        candidates.push(mint);
+      }
+    }
+    return candidates;
+  }
+  async _refundOtherProvidersForTopUp(baseUrl, mintUrl) {
+    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
+    const toRefund = pendingDistribution.filter(
+      (pending) => pending.baseUrl !== baseUrl
+    );
+    const refundResults = 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 refundResults) {
+      if (result.status === "fulfilled" && result.value.success) {
+        this.storageAdapter.removeToken(result.value.baseUrl);
+      }
+    }
+  }
+  /**
+   * 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,
@@ -1223,7 +1740,7 @@ var BalanceManager = class {
    */
   async _recoverFailedTopUp(cashuToken) {
     try {
-      await this.walletAdapter.receiveToken(cashuToken);
+      await this.cashuSpender.receiveToken(cashuToken);
     } catch (error) {
       console.error(
         "[BalanceManager._recoverFailedTopUp] Failed to recover token",
@@ -1236,9 +1753,7 @@ var BalanceManager = class {
    */
   _handleRefundError(error, mintUrl, requestId) {
     if (error instanceof Error) {
-      if (error.message.includes(
-        "NetworkError when attempting to fetch resource"
-      ) || error.message.includes("Failed to fetch") || error.message.includes("Load failed")) {
+      if (isNetworkErrorMessage(error.message)) {
         return {
           success: false,
           message: `Failed to connect to the mint: ${mintUrl}`,
@@ -1276,25 +1791,29 @@ var BalanceManager = class {
       });
       if (response.ok) {
         const data = await response.json();
+        console.log("TOKENA FASJDFAS", data);
         return {
           amount: data.balance,
           reserved: data.reserved ?? 0,
           unit: "msat",
           apiKey: data.api_key
         };
+      } else {
+        console.log(response.status);
+        const data = await response.json();
+        console.log("FAILED ", data);
       }
-    } catch {
+    } catch (error) {
+      console.error("ERRORR IN RESTPONSE", error);
     }
-    return { amount: 0, reserved: 0, unit: "sat", apiKey: "" };
+    return { amount: -1, reserved: 0, unit: "sat", apiKey: "" };
   }
   /**
    * Handle topup errors with specific error types
    */
   _handleTopUpError(error, mintUrl, requestId) {
     if (error instanceof Error) {
-      if (error.message.includes(
-        "NetworkError when attempting to fetch resource"
-      ) || error.message.includes("Failed to fetch") || error.message.includes("Load failed")) {
+      if (isNetworkErrorMessage(error.message)) {
         return {
           success: false,
           message: `Failed to connect to the mint: ${mintUrl}`,
@@ -1690,6 +2209,9 @@ function calculateImageTokens(width, height, detail = "auto") {
   const numTiles = tilesWidth * tilesHeight;
   return 85 + 170 * numTiles;
 }
+function isInsecureHttpUrl(url) {
+  return url.startsWith("http://");
+}
 var ProviderManager = class {
   constructor(providerRegistry) {
     this.providerRegistry = providerRegistry;
@@ -1731,7 +2253,7 @@ var ProviderManager = class {
         if (baseUrl === currentBaseUrl || this.failedProviders.has(baseUrl) || disabledProviders.has(baseUrl)) {
           continue;
         }
-        if (!torMode && isOnionUrl(baseUrl)) {
+        if (!torMode && (isOnionUrl(baseUrl) || isInsecureHttpUrl(baseUrl))) {
           continue;
         }
         const model = models.find((m) => m.id === modelId);
@@ -1775,7 +2297,8 @@ var ProviderManager = class {
     const torMode = isTorContext();
     for (const [baseUrl, models] of Object.entries(allProviders)) {
       if (disabledProviders.has(baseUrl)) continue;
-      if (!torMode && isOnionUrl(baseUrl)) continue;
+      if (!torMode && (isOnionUrl(baseUrl) || isInsecureHttpUrl(baseUrl)))
+        continue;
       const model = models.find((m) => m.id === modelId);
       if (!model) continue;
       const cost = model.sats_pricing?.completion ?? 0;
@@ -1798,7 +2321,8 @@ var ProviderManager = class {
     for (const [baseUrl, models] of Object.entries(allModels)) {
       if (!includeDisabled && disabledProviders.has(baseUrl)) continue;
       if (torMode && !baseUrl.includes(".onion")) continue;
-      if (!torMode && baseUrl.includes(".onion")) continue;
+      if (!torMode && (baseUrl.includes(".onion") || isInsecureHttpUrl(baseUrl)))
+        continue;
       const match = models.find(
         (model) => this.normalizeModelId(model.id) === normalizedId
       );
@@ -1915,12 +2439,17 @@ var ProviderManager = class {
 };
 
 // client/RoutstrClient.ts
+var TOPUP_MARGIN = 0.7;
 var RoutstrClient = class {
   constructor(walletAdapter, storageAdapter, providerRegistry, alertLevel, mode = "xcashu") {
     this.walletAdapter = walletAdapter;
     this.storageAdapter = storageAdapter;
     this.providerRegistry = providerRegistry;
-    this.balanceManager = new BalanceManager(walletAdapter, storageAdapter);
+    this.balanceManager = new BalanceManager(
+      walletAdapter,
+      storageAdapter,
+      providerRegistry
+    );
     this.cashuSpender = new CashuSpender(
       walletAdapter,
       storageAdapter,
@@ -1938,12 +2467,39 @@ var RoutstrClient = class {
   providerManager;
   alertLevel;
   mode;
+  debugLevel = "WARN";
   /**
    * Get the current client mode
    */
   getMode() {
     return this.mode;
   }
+  getDebugLevel() {
+    return this.debugLevel;
+  }
+  setDebugLevel(level) {
+    this.debugLevel = level;
+  }
+  _log(level, ...args) {
+    const levelPriority = {
+      DEBUG: 0,
+      WARN: 1,
+      ERROR: 2
+    };
+    if (levelPriority[level] >= levelPriority[this.debugLevel]) {
+      switch (level) {
+        case "DEBUG":
+          console.log(...args);
+          break;
+        case "WARN":
+          console.warn(...args);
+          break;
+        case "ERROR":
+          console.error(...args);
+          break;
+      }
+    }
+  }
   /**
    * Get the CashuSpender instance
    */
@@ -2007,6 +2563,7 @@ var RoutstrClient = class {
       amount: requiredSats,
       baseUrl
     });
+    this._log("DEBUG", token, baseUrl);
     let requestBody = body;
     if (body && typeof body === "object") {
       const bodyObj = body;
@@ -2029,9 +2586,11 @@ var RoutstrClient = class {
       selectedModel
     });
     const tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
+    const baseUrlUsed = response.baseUrl || baseUrl;
+    const tokenUsed = response.token || token;
     await this._handlePostResponseBalanceUpdate({
-      token,
-      baseUrl,
+      token: tokenUsed,
+      baseUrl: baseUrlUsed,
       initialTokenBalance: tokenBalanceInSats,
       response
     });
@@ -2166,19 +2725,34 @@ var RoutstrClient = class {
     const { path, method, body, baseUrl, token, headers } = params;
     try {
       const url = `${baseUrl.replace(/\/$/, "")}${path}`;
+      if (this.mode === "xcashu") this._log("DEBUG", "HEADERS,", headers);
       const response = await fetch(url, {
         method,
         headers,
         body: body === void 0 || method === "GET" ? void 0 : JSON.stringify(body)
       });
+      if (this.mode === "xcashu") this._log("DEBUG", "response,", response);
       response.baseUrl = baseUrl;
+      response.token = token;
       if (!response.ok) {
-        return await this._handleErrorResponse(response, params, token);
+        const requestId = response.headers.get("x-routstr-request-id") || void 0;
+        return await this._handleErrorResponse(
+          params,
+          token,
+          response.status,
+          requestId,
+          this.mode === "xcashu" ? response.headers.get("x-cashu") ?? void 0 : void 0
+        );
       }
       return response;
     } catch (error) {
       if (this._isNetworkError(error?.message || "")) {
-        return await this._handleNetworkError(error, params);
+        return await this._handleErrorResponse(
+          params,
+          token,
+          -1
+          // just for Network Error to skip all statuses
+        );
       }
       throw error;
     }
@@ -2186,250 +2760,239 @@ var RoutstrClient = class {
   /**
    * Handle error responses with failover
    */
-  async _handleErrorResponse(response, params, token) {
+  async _handleErrorResponse(params, token, status, requestId, xCashuRefundToken) {
     const { path, method, body, selectedModel, baseUrl, mintUrl } = params;
-    const status = response.status;
-    if (this.mode === "apikeys") {
-      console.log("error ;", status);
-      if (status === 401 || status === 403) {
-        const parentApiKey = this.storageAdapter.getApiKey(baseUrl);
-        if (parentApiKey) {
-          try {
-            const childKeyResult = await this._createChildKey(
-              baseUrl,
-              parentApiKey
+    let tryNextProvider = false;
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _handleErrorResponse: status=${status}, baseUrl=${baseUrl}, mode=${this.mode}, token preview=${token}, requestId=${requestId}`
+    );
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _handleErrorResponse: Attempting to receive/restore token for ${baseUrl}`
+    );
+    if (params.token.startsWith("cashu")) {
+      const tryReceiveTokenResult = await this.cashuSpender.receiveToken(
+        params.token
+      );
+      if (tryReceiveTokenResult.success) {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${tryReceiveTokenResult.amount}`
+        );
+        tryNextProvider = true;
+        if (this.mode === "lazyrefund")
+          this.storageAdapter.removeToken(baseUrl);
+      } else {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Failed to receive token. `
+        );
+      }
+    }
+    if (this.mode === "xcashu") {
+      if (xCashuRefundToken) {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Attempting to receive xcashu refund token, preview=${xCashuRefundToken.substring(0, 20)}...`
+        );
+        try {
+          const receiveResult = await this.cashuSpender.receiveToken(xCashuRefundToken);
+          if (receiveResult.success) {
+            this._log(
+              "DEBUG",
+              `[RoutstrClient] _handleErrorResponse: xcashu refund received, amount=${receiveResult.amount}`
             );
-            this.storageAdapter.setChildKey(
+            tryNextProvider = true;
+          } else
+            throw new ProviderError(
               baseUrl,
-              childKeyResult.childKey,
-              childKeyResult.balance,
-              childKeyResult.validityDate,
-              childKeyResult.balanceLimit
+              status,
+              "xcashu refund failed",
+              requestId
             );
-            return this._makeRequest({
-              ...params,
-              token: childKeyResult.childKey,
-              headers: this._withAuthHeader(
-                params.baseHeaders,
-                childKeyResult.childKey
-              )
-            });
-          } catch (e) {
-          }
-        }
-      } else if (status === 402) {
-        const parentApiKey = this.storageAdapter.getApiKey(baseUrl);
-        if (parentApiKey) {
-          const topupResult = await this.balanceManager.topUp({
-            mintUrl,
+        } catch (error) {
+          this._log("ERROR", "[xcashu] Failed to receive refund token:", error);
+          throw new ProviderError(
             baseUrl,
-            amount: params.requiredSats * 3,
-            token: parentApiKey
-          });
-          console.log(topupResult);
-          return this._makeRequest({
-            ...params,
-            token: params.token,
-            headers: this._withAuthHeader(params.baseHeaders, params.token)
-          });
+            status,
+            "[xcashu] Failed to receive refund token",
+            requestId
+          );
         }
+      } else {
+        if (!tryNextProvider)
+          throw new ProviderError(
+            baseUrl,
+            status,
+            "[xcashu] Failed to receive refund token",
+            requestId
+          );
       }
-      throw new ProviderError(baseUrl, status, await response.text());
     }
-    await this.balanceManager.refund({
-      mintUrl,
-      baseUrl,
-      token
-    });
-    this.providerManager.markFailed(baseUrl);
-    this.storageAdapter.removeToken(baseUrl);
-    if (status === 401 || status === 403 || status === 402 || status === 413 || status === 400 || status === 500 || status === 502) {
-      if (!selectedModel) {
-        throw new ProviderError(baseUrl, status, await response.text());
-      }
-      const nextProvider = this.providerManager.findNextBestProvider(
-        selectedModel.id,
-        baseUrl
+    if (status === 402 && !tryNextProvider && (this.mode === "apikeys" || this.mode === "lazyrefund")) {
+      const topupResult = await this.balanceManager.topUp({
+        mintUrl,
+        baseUrl,
+        amount: params.requiredSats * TOPUP_MARGIN,
+        token: params.token
+      });
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Topup result for ${baseUrl}: success=${topupResult.success}, message=${topupResult.message}`
       );
-      if (nextProvider) {
-        const newModel = await this.providerManager.getModelForProvider(
-          nextProvider,
-          selectedModel.id
-        ) ?? selectedModel;
-        const messagesForPricing = Array.isArray(
-          body?.messages
-        ) ? body.messages : [];
-        const newRequiredSats = this.providerManager.getRequiredSatsForModel(
-          newModel,
-          messagesForPricing,
-          params.maxTokens
+      if (!topupResult.success) {
+        const message = topupResult.message || "";
+        if (message.includes("Insufficient balance")) {
+          const needMatch = message.match(/need (\d+)/);
+          const haveMatch = message.match(/have (\d+)/);
+          const required = needMatch ? parseInt(needMatch[1], 10) : params.requiredSats;
+          const available = haveMatch ? parseInt(haveMatch[1], 10) : 0;
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Insufficient balance, need=${required}, have=${available}`
+          );
+          throw new InsufficientBalanceError(required, available);
+        } else {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Topup failed with non-insufficient-balance error, will try next provider`
+          );
+          tryNextProvider = true;
+        }
+      } else {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Topup successful, will retry with new token`
         );
-        const spendResult = await this.cashuSpender.spend({
-          mintUrl,
-          amount: newRequiredSats,
-          baseUrl: nextProvider,
-          reuseToken: true
+      }
+      if (!tryNextProvider)
+        return this._makeRequest({
+          ...params,
+          token: params.token,
+          headers: this._withAuthHeader(params.baseHeaders, params.token)
         });
-        if (spendResult.status === "failed" || !spendResult.token) {
-          if (spendResult.errorDetails) {
-            throw new InsufficientBalanceError(
-              spendResult.errorDetails.required,
-              spendResult.errorDetails.available,
-              spendResult.errorDetails.maxMintBalance,
-              spendResult.errorDetails.maxMintUrl
+    }
+    if ((status === 401 || status === 403 || status === 413 || status === 400 || status === 500 || status === 502 || status === 503 || status === 504 || status === 521) && !tryNextProvider) {
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Status ${status} (auth/server error), attempting refund for ${baseUrl}, mode=${this.mode}`
+      );
+      if (this.mode === "lazyrefund") {
+        try {
+          const refundResult = await this.balanceManager.refund({
+            mintUrl,
+            baseUrl,
+            token: params.token
+          });
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: Lazyrefund result: success=${refundResult.success}`
+          );
+          if (refundResult.success) this.storageAdapter.removeToken(baseUrl);
+          else
+            throw new ProviderError(
+              baseUrl,
+              status,
+              "refund failed",
+              requestId
             );
-          }
-          throw new Error(
-            spendResult.error || `Insufficient balance for ${nextProvider}`
+        } catch (error) {
+          throw new ProviderError(
+            baseUrl,
+            status,
+            "Failed to refund token",
+            requestId
           );
         }
-        return this._makeRequest({
-          ...params,
-          path,
-          method,
-          body,
-          baseUrl: nextProvider,
-          selectedModel: newModel,
-          token: spendResult.token,
-          requiredSats: newRequiredSats,
-          headers: this._withAuthHeader(params.baseHeaders, spendResult.token)
+      } else if (this.mode === "apikeys") {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Attempting API key refund for ${baseUrl}, key preview=${token}`
+        );
+        const initialBalance = await this.balanceManager.getTokenBalance(
+          token,
+          baseUrl
+        );
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: Initial API key balance: ${initialBalance.amount}`
+        );
+        const refundResult = await this.balanceManager.refundApiKey({
+          mintUrl,
+          baseUrl,
+          apiKey: token
         });
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _handleErrorResponse: API key refund result: success=${refundResult.success}, message=${refundResult.message}`
+        );
+        if (!refundResult.success && initialBalance.amount > 0) {
+          throw new ProviderError(
+            baseUrl,
+            status,
+            refundResult.message ?? "Unknown error"
+          );
+        } else {
+          this.storageAdapter.removeApiKey(baseUrl);
+        }
       }
     }
-    throw new ProviderError(baseUrl, status, await response.text());
-  }
-  /**
-   * Handle network errors with failover
-   */
-  async _handleNetworkError(error, params) {
-    const { path, method, body, selectedModel, baseUrl, mintUrl } = params;
-    await this.balanceManager.refund({
-      mintUrl,
-      baseUrl,
-      token: params.token
-    });
     this.providerManager.markFailed(baseUrl);
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _handleErrorResponse: Marked provider ${baseUrl} as failed`
+    );
     if (!selectedModel) {
-      throw error;
+      throw new ProviderError(
+        baseUrl,
+        status,
+        "Funny, no selected model. HMM. "
+      );
     }
     const nextProvider = this.providerManager.findNextBestProvider(
       selectedModel.id,
       baseUrl
     );
-    if (!nextProvider) {
-      throw new FailoverError(baseUrl, Array.from(this.providerManager));
-    }
-    const newModel = await this.providerManager.getModelForProvider(
-      nextProvider,
-      selectedModel.id
-    ) ?? selectedModel;
-    const messagesForPricing = Array.isArray(
-      body?.messages
-    ) ? body.messages : [];
-    const newRequiredSats = this.providerManager.getRequiredSatsForModel(
-      newModel,
-      messagesForPricing,
-      params.maxTokens
-    );
-    const spendResult = await this.cashuSpender.spend({
-      mintUrl,
-      amount: newRequiredSats,
-      baseUrl: nextProvider,
-      reuseToken: true
-    });
-    if (spendResult.status === "failed" || !spendResult.token) {
-      if (spendResult.errorDetails) {
-        throw new InsufficientBalanceError(
-          spendResult.errorDetails.required,
-          spendResult.errorDetails.available,
-          spendResult.errorDetails.maxMintBalance,
-          spendResult.errorDetails.maxMintUrl
-        );
-      }
-      throw new Error(
-        spendResult.error || `Insufficient balance for ${nextProvider}`
+    if (nextProvider) {
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Failing over to next provider: ${nextProvider}, model: ${selectedModel.id}`
       );
+      const newModel = await this.providerManager.getModelForProvider(
+        nextProvider,
+        selectedModel.id
+      ) ?? selectedModel;
+      const messagesForPricing = Array.isArray(
+        body?.messages
+      ) ? body.messages : [];
+      const newRequiredSats = this.providerManager.getRequiredSatsForModel(
+        newModel,
+        messagesForPricing,
+        params.maxTokens
+      );
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Creating new token for failover provider ${nextProvider}, required sats: ${newRequiredSats}`
+      );
+      const spendResult = await this._spendToken({
+        mintUrl,
+        amount: newRequiredSats,
+        baseUrl: nextProvider
+      });
+      return this._makeRequest({
+        ...params,
+        path,
+        method,
+        body,
+        baseUrl: nextProvider,
+        selectedModel: newModel,
+        token: spendResult.token,
+        requiredSats: newRequiredSats,
+        headers: this._withAuthHeader(params.baseHeaders, spendResult.token)
+      });
     }
-    return this._makeRequest({
-      ...params,
-      path,
-      method,
-      body,
-      baseUrl: nextProvider,
-      selectedModel: newModel,
-      token: spendResult.token,
-      requiredSats: newRequiredSats,
-      headers: this._withAuthHeader(params.baseHeaders, spendResult.token)
-    });
-  }
-  /**
-   * Handle post-response refund and balance updates
-   */
-  async _handlePostResponseRefund(params) {
-    const {
-      mintUrl,
-      baseUrl,
-      tokenBalance,
-      tokenBalanceUnit,
-      initialBalance,
-      selectedModel,
-      streamingResult,
-      callbacks
-    } = params;
-    const tokenBalanceInSats = tokenBalanceUnit === "msat" ? tokenBalance / 1e3 : tokenBalance;
-    const estimatedCosts = this._getEstimatedCosts(
-      selectedModel,
-      streamingResult
-    );
-    const refundResult = await this.balanceManager.refund({
-      mintUrl,
-      baseUrl
-    });
-    if (refundResult.success) {
-      refundResult.refundedAmount !== void 0 ? refundResult.refundedAmount / 1e3 : 0;
-    }
-    let satsSpent;
-    if (refundResult.success) {
-      if (refundResult.refundedAmount !== void 0) {
-        satsSpent = tokenBalanceInSats - refundResult.refundedAmount / 1e3;
-      } else if (refundResult.message?.includes("No API key to refund")) {
-        satsSpent = 0;
-      } else {
-        satsSpent = tokenBalanceInSats;
-      }
-      const newBalance = initialBalance - satsSpent;
-      callbacks.onBalanceUpdate(newBalance);
-    } else {
-      if (refundResult.message?.includes("Refund request failed with status 401")) {
-        this.storageAdapter.removeToken(baseUrl);
-      }
-      satsSpent = tokenBalanceInSats;
-    }
-    const netCosts = satsSpent - estimatedCosts;
-    const overchargeThreshold = tokenBalanceUnit === "msat" ? 0.05 : 1;
-    if (netCosts > overchargeThreshold) {
-      if (this.alertLevel === "max") {
-        callbacks.onMessageAppend({
-          role: "system",
-          content: `ATTENTION: Provider may be overcharging. Estimated: ${estimatedCosts.toFixed(
-            tokenBalanceUnit === "msat" ? 3 : 0
-          )}, Actual: ${satsSpent.toFixed(
-            tokenBalanceUnit === "msat" ? 3 : 0
-          )}`
-        });
-      }
-    }
-    const newTransaction = {
-      type: "spent",
-      amount: satsSpent,
-      timestamp: Date.now(),
-      status: "success",
-      model: selectedModel.id,
-      message: "Tokens spent",
-      balance: initialBalance - satsSpent
-    };
-    callbacks.onTransactionUpdate(newTransaction);
-    return satsSpent;
+    throw new FailoverError(baseUrl, Array.from(this.providerManager));
   }
   /**
    * Handle post-response balance update for all modes
@@ -2441,10 +3004,10 @@ var RoutstrClient = class {
       const refundToken = response.headers.get("x-cashu") ?? void 0;
       if (refundToken) {
         try {
-          const receiveResult = await this.walletAdapter.receiveToken(refundToken);
+          const receiveResult = await this.cashuSpender.receiveToken(refundToken);
           satsSpent = initialTokenBalance - receiveResult.amount * (receiveResult.unit == "sat" ? 1 : 1e3);
         } catch (error) {
-          console.error("[xcashu] Failed to receive refund token:", error);
+          this._log("ERROR", "[xcashu] Failed to receive refund token:", error);
         }
       }
     } else if (this.mode === "lazyrefund") {
@@ -2457,13 +3020,24 @@ var RoutstrClient = class {
       satsSpent = initialTokenBalance - latestTokenBalance;
     } else if (this.mode === "apikeys") {
       try {
-        const latestBalanceInfo = await this._getApiKeyBalance(baseUrl, token);
-        console.log("LATEST BANAL", latestBalanceInfo);
+        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
+          token,
+          baseUrl
+        );
+        this._log(
+          "DEBUG",
+          "LATEST Balance",
+          latestBalanceInfo.amount,
+          latestBalanceInfo.reserved,
+          latestBalanceInfo.apiKey,
+          baseUrl
+        );
         const latestTokenBalance = latestBalanceInfo.unit === "msat" ? latestBalanceInfo.amount / 1e3 : latestBalanceInfo.amount;
         this.storageAdapter.updateChildKeyBalance(baseUrl, latestTokenBalance);
+        this.storageAdapter.updateApiKeyBalance(baseUrl, latestTokenBalance);
         satsSpent = initialTokenBalance - latestTokenBalance;
       } catch (e) {
-        console.warn("Could not get updated API key balance:", e);
+        this._log("WARN", "Could not get updated API key balance:", e);
         satsSpent = fallbackSatsSpent ?? initialTokenBalance;
       }
     }
@@ -2544,28 +3118,6 @@ var RoutstrClient = class {
       validityDate: data.validity_date
     };
   }
-  /**
-   * Get balance for an API key from the provider
-   */
-  async _getApiKeyBalance(baseUrl, apiKey) {
-    try {
-      const response = await fetch(`${baseUrl}v1/wallet/info`, {
-        headers: {
-          Authorization: `Bearer ${apiKey}`
-        }
-      });
-      if (response.ok) {
-        const data = await response.json();
-        console.log(data);
-        return {
-          amount: data.balance,
-          unit: "msat"
-        };
-      }
-    } catch {
-    }
-    return { amount: 0, unit: "sat" };
-  }
   /**
    * Calculate estimated costs from usage
    */
@@ -2583,7 +3135,7 @@ var RoutstrClient = class {
    * Get pending cashu token amount
    */
   _getPendingCashuTokenAmount() {
-    const distribution = this.storageAdapter.getPendingTokenDistribution();
+    const distribution = this.storageAdapter.getCachedTokenDistribution();
     return distribution.reduce((total, item) => total + item.amount, 0);
   }
   /**
@@ -2596,9 +3148,14 @@ var RoutstrClient = class {
    * Handle errors and notify callbacks
    */
   _handleError(error, callbacks) {
-    console.error("RoutstrClient error:", error);
+    this._log("ERROR", "[RoutstrClient] _handleError: Error occurred", error);
     if (error instanceof Error) {
-      const modifiedErrorMsg = error.message.includes("Error in input stream") || error.message.includes("Load failed") ? "AI stream was cut off, turn on Keep Active or please try again" : error.message;
+      const isStreamError = error.message.includes("Error in input stream") || error.message.includes("Load failed");
+      const modifiedErrorMsg = isStreamError ? "AI stream was cut off, turn on Keep Active or please try again" : error.message;
+      this._log(
+        "ERROR",
+        `[RoutstrClient] _handleError: Error type=${error.constructor.name}, message=${modifiedErrorMsg}, isStreamError=${isStreamError}`
+      );
       callbacks.onMessageAppend({
         role: "system",
         content: "Uncaught Error: " + modifiedErrorMsg + (this.alertLevel === "max" ? " | " + error.stack : "")
@@ -2625,113 +3182,127 @@ var RoutstrClient = class {
    */
   async _spendToken(params) {
     const { mintUrl, amount, baseUrl } = params;
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _spendToken: mode=${this.mode}, amount=${amount}, baseUrl=${baseUrl}, mintUrl=${mintUrl}`
+    );
     if (this.mode === "apikeys") {
       let parentApiKey = this.storageAdapter.getApiKey(baseUrl);
       if (!parentApiKey) {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _spendToken: No existing API key for ${baseUrl}, creating new one via Cashu`
+        );
         const spendResult2 = await this.cashuSpender.spend({
           mintUrl,
-          amount: amount * 3,
+          amount: amount * TOPUP_MARGIN,
           baseUrl: "",
           reuseToken: false
         });
-        if (spendResult2.status === "failed" || !spendResult2.token) {
-          const errorMsg = spendResult2.error || `Insufficient balance. Need ${amount} sats.`;
-          if (this._isNetworkError(errorMsg)) {
-            throw new Error(
-              `Your mint ${mintUrl} is unreachable or is blocking your IP. Please try again later or switch mints.`
+        if (!spendResult2.token) {
+          this._log(
+            "ERROR",
+            `[RoutstrClient] _spendToken: Failed to create Cashu token for API key creation, error:`,
+            spendResult2.error
+          );
+          throw new Error(
+            `[RoutstrClient] _spendToken: Failed to create Cashu token for API key creation, error: ${spendResult2.error}`
+          );
+        } else {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult2.token}`
+          );
+        }
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _spendToken: Created API key for ${baseUrl}, key preview: ${spendResult2.token}, balance: ${spendResult2.balance}`
+        );
+        try {
+          this.storageAdapter.setApiKey(baseUrl, spendResult2.token);
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("ApiKey already exists")) {
+            const tryReceiveTokenResult = await this.cashuSpender.receiveToken(
+              spendResult2.token
             );
-          }
-          if (spendResult2.errorDetails) {
-            throw new InsufficientBalanceError(
-              spendResult2.errorDetails.required,
-              spendResult2.errorDetails.available,
-              spendResult2.errorDetails.maxMintBalance,
-              spendResult2.errorDetails.maxMintUrl
+            if (tryReceiveTokenResult.success) {
+              this._log(
+                "DEBUG",
+                `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${tryReceiveTokenResult.amount}`
+              );
+            } else {
+              this._log(
+                "DEBUG",
+                `[RoutstrClient] _handleErrorResponse: Token restore failed or not needed`
+              );
+            }
+            this._log(
+              "DEBUG",
+              `[RoutstrClient] _spendToken: API key already exists for ${baseUrl}, using existing key`
             );
+          } else {
+            throw error;
           }
-          throw new Error(errorMsg);
         }
-        const apiKeyCreated = await this.balanceManager.getTokenBalance(
-          spendResult2.token,
-          baseUrl
+        parentApiKey = this.storageAdapter.getApiKey(baseUrl);
+      } else {
+        this._log(
+          "DEBUG",
+          `[RoutstrClient] _spendToken: Using existing API key for ${baseUrl}, key preview: ${parentApiKey.key}`
         );
-        parentApiKey = apiKeyCreated.apiKey;
-        this.storageAdapter.setApiKey(baseUrl, parentApiKey);
-      }
-      let childKeyEntry = this.storageAdapter.getChildKey(baseUrl);
-      if (!childKeyEntry) {
-        try {
-          const childKeyResult = await this._createChildKey(
-            baseUrl,
-            parentApiKey
-          );
-          this.storageAdapter.setChildKey(
-            baseUrl,
-            childKeyResult.childKey,
-            childKeyResult.balance,
-            childKeyResult.validityDate,
-            childKeyResult.balanceLimit
-          );
-          childKeyEntry = {
-            parentBaseUrl: baseUrl,
-            childKey: childKeyResult.childKey,
-            balance: childKeyResult.balance,
-            balanceLimit: childKeyResult.balanceLimit,
-            validityDate: childKeyResult.validityDate,
-            createdAt: Date.now()
-          };
-        } catch (e) {
-          console.warn("Could not create child key, using parent key:", e);
-          childKeyEntry = {
-            parentBaseUrl: baseUrl,
-            childKey: parentApiKey,
-            balance: 0,
-            createdAt: Date.now()
-          };
-        }
       }
-      let tokenBalance = childKeyEntry.balance;
+      let tokenBalance = 0;
       let tokenBalanceUnit = "sat";
-      if (tokenBalance === 0) {
+      const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+      const distributionForBaseUrl = apiKeyDistribution.find(
+        (d) => d.baseUrl === baseUrl
+      );
+      if (distributionForBaseUrl) {
+        tokenBalance = distributionForBaseUrl.amount;
+      }
+      if (tokenBalance === 0 && parentApiKey) {
         try {
-          const balanceInfo = await this._getApiKeyBalance(
-            baseUrl,
-            childKeyEntry.childKey
+          const balanceInfo = await this.balanceManager.getTokenBalance(
+            parentApiKey.key,
+            baseUrl
           );
           tokenBalance = balanceInfo.amount;
           tokenBalanceUnit = balanceInfo.unit;
         } catch (e) {
-          console.warn("Could not get initial API key balance:", e);
+          this._log("WARN", "Could not get initial API key balance:", e);
         }
       }
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _spendToken: Returning token with balance=${tokenBalance} ${tokenBalanceUnit}`
+      );
       return {
-        token: childKeyEntry.childKey,
+        token: parentApiKey?.key ?? "",
         tokenBalance,
         tokenBalanceUnit
       };
     }
+    this._log(
+      "DEBUG",
+      `[RoutstrClient] _spendToken: Calling CashuSpender.spend for amount=${amount}, mintUrl=${mintUrl}, mode=${this.mode}`
+    );
     const spendResult = await this.cashuSpender.spend({
       mintUrl,
       amount,
-      baseUrl,
-      reuseToken: true
+      baseUrl: this.mode === "lazyrefund" ? baseUrl : "",
+      reuseToken: this.mode === "lazyrefund"
     });
-    if (spendResult.status === "failed" || !spendResult.token) {
-      const errorMsg = spendResult.error || `Insufficient balance. Need ${amount} sats.`;
-      if (this._isNetworkError(errorMsg)) {
-        throw new Error(
-          `Your mint ${mintUrl} is unreachable or is blocking your IP. Please try again later or switch mints.`
-        );
-      }
-      if (spendResult.errorDetails) {
-        throw new InsufficientBalanceError(
-          spendResult.errorDetails.required,
-          spendResult.errorDetails.available,
-          spendResult.errorDetails.maxMintBalance,
-          spendResult.errorDetails.maxMintUrl
-        );
-      }
-      throw new Error(errorMsg);
+    if (!spendResult.token) {
+      this._log(
+        "ERROR",
+        `[RoutstrClient] _spendToken: CashuSpender.spend failed, error:`,
+        spendResult.error
+      );
+    } else {
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _spendToken: Cashu token created, token preview: ${spendResult.token}, balance: ${spendResult.balance} ${spendResult.unit ?? "sat"}`
+      );
     }
     return {
       token: spendResult.token,
@@ -2773,7 +3344,7 @@ var isQuotaExceeded = (error) => {
 };
 var NON_CRITICAL_KEYS = /* @__PURE__ */ new Set(["modelsFromAllProviders"]);
 var localStorageDriver = {
-  getItem(key, defaultValue) {
+  async getItem(key, defaultValue) {
     if (!canUseLocalStorage()) return defaultValue;
     try {
       const item = window.localStorage.getItem(key);
@@ -2801,7 +3372,7 @@ var localStorageDriver = {
       return defaultValue;
     }
   },
-  setItem(key, value) {
+  async setItem(key, value) {
     if (!canUseLocalStorage()) return;
     try {
       window.localStorage.setItem(key, JSON.stringify(value));
@@ -2831,7 +3402,7 @@ var localStorageDriver = {
       console.error(`Error storing item with key "${key}":`, error);
     }
   },
-  removeItem(key) {
+  async removeItem(key) {
     if (!canUseLocalStorage()) return;
     try {
       window.localStorage.removeItem(key);
@@ -2850,7 +3421,7 @@ var createMemoryDriver = (seed) => {
     }
   }
   return {
-    getItem(key, defaultValue) {
+    async getItem(key, defaultValue) {
       const item = store.get(key);
       if (item === void 0) return defaultValue;
       try {
@@ -2862,17 +3433,25 @@ var createMemoryDriver = (seed) => {
         throw parseError;
       }
     },
-    setItem(key, value) {
+    async setItem(key, value) {
       store.set(key, JSON.stringify(value));
     },
-    removeItem(key) {
+    async removeItem(key) {
       store.delete(key);
     }
   };
 };
 
 // storage/drivers/sqlite.ts
+var isBun = () => {
+  return typeof process.versions.bun !== "undefined";
+};
 var createDatabase = (dbPath) => {
+  if (isBun()) {
+    throw new Error(
+      "SQLite driver not supported in Bun. Use createMemoryDriver() instead."
+    );
+  }
   let Database = null;
   try {
     Database = __require("better-sqlite3");
@@ -2897,7 +3476,7 @@ var createSqliteDriver = (options = {}) => {
   );
   const deleteStmt = db.prepare(`DELETE FROM ${tableName} WHERE key = ?`);
   return {
-    getItem(key, defaultValue) {
+    async getItem(key, defaultValue) {
       try {
         const row = selectStmt.get(key);
         if (!row || typeof row.value !== "string") return defaultValue;
@@ -2914,14 +3493,14 @@ var createSqliteDriver = (options = {}) => {
         return defaultValue;
       }
     },
-    setItem(key, value) {
+    async setItem(key, value) {
       try {
         upsertStmt.run(key, JSON.stringify(value));
       } catch (error) {
         console.error(`SQLite setItem failed for key "${key}":`, error);
       }
     },
-    removeItem(key) {
+    async removeItem(key) {
       try {
         deleteStmt.run(key);
       } catch (error) {
@@ -2931,6 +3510,96 @@ var createSqliteDriver = (options = {}) => {
   };
 };
 
+// storage/drivers/indexedDB.ts
+var openDatabase = (dbName, storeName) => {
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.open(dbName, 1);
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        db.createObjectStore(storeName);
+      }
+    };
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error);
+  });
+};
+var createIndexedDBDriver = (options = {}) => {
+  const dbName = options.dbName || "routstr-sdk";
+  const storeName = options.storeName || "sdk_storage";
+  let dbPromise = null;
+  const getDb = () => {
+    if (!dbPromise) {
+      dbPromise = openDatabase(dbName, storeName);
+    }
+    return dbPromise;
+  };
+  return {
+    async getItem(key, defaultValue) {
+      try {
+        const db = await getDb();
+        return new Promise((resolve, reject) => {
+          const tx = db.transaction(storeName, "readonly");
+          const store = tx.objectStore(storeName);
+          const request = store.get(key);
+          request.onsuccess = () => {
+            const raw = request.result;
+            if (raw === void 0) {
+              resolve(defaultValue);
+              return;
+            }
+            if (typeof raw === "string") {
+              try {
+                resolve(JSON.parse(raw));
+              } catch {
+                if (typeof defaultValue === "string") {
+                  resolve(raw);
+                } else {
+                  resolve(defaultValue);
+                }
+              }
+            } else {
+              resolve(raw);
+            }
+          };
+          request.onerror = () => reject(request.error);
+        });
+      } catch (error) {
+        console.error(`IndexedDB getItem failed for key "${key}":`, error);
+        return defaultValue;
+      }
+    },
+    async setItem(key, value) {
+      try {
+        const db = await getDb();
+        return new Promise((resolve, reject) => {
+          const tx = db.transaction(storeName, "readwrite");
+          const store = tx.objectStore(storeName);
+          store.put(JSON.stringify(value), key);
+          tx.oncomplete = () => resolve();
+          tx.onerror = () => reject(tx.error);
+        });
+      } catch (error) {
+        console.error(`IndexedDB setItem failed for key "${key}":`, error);
+      }
+    },
+    async removeItem(key) {
+      try {
+        const db = await getDb();
+        return new Promise((resolve, reject) => {
+          const tx = db.transaction(storeName, "readwrite");
+          const store = tx.objectStore(storeName);
+          store.delete(key);
+          tx.oncomplete = () => resolve();
+          tx.onerror = () => reject(tx.error);
+        });
+      } catch (error) {
+        console.error(`IndexedDB removeItem failed for key "${key}":`, error);
+      }
+    }
+  };
+};
+
 // storage/keys.ts
 var SDK_STORAGE_KEYS = {
   MODELS_FROM_ALL_PROVIDERS: "modelsFromAllProviders",
@@ -2943,7 +3612,9 @@ var SDK_STORAGE_KEYS = {
   LAST_BASE_URLS_UPDATE: "lastBaseUrlsUpdate",
   LOCAL_CASHU_TOKENS: "local_cashu_tokens",
   API_KEYS: "api_keys",
-  CHILD_KEYS: "child_keys"
+  CHILD_KEYS: "child_keys",
+  ROUTSTR21_MODELS: "routstr21Models",
+  CACHED_RECEIVE_TOKENS: "cached_receive_tokens"
 };
 
 // storage/store.ts
@@ -2961,97 +3632,146 @@ var getTokenBalance = (token) => {
     return 0;
   }
 };
-var createSdkStore = ({ driver }) => {
-  return vanilla.createStore((set, get) => ({
-    modelsFromAllProviders: Object.fromEntries(
-      Object.entries(
-        driver.getItem(
-          SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
-          {}
-        )
-      ).map(([baseUrl, models]) => [normalizeBaseUrl(baseUrl), models])
+var createSdkStore = async ({
+  driver
+}) => {
+  const [
+    rawModels,
+    lastUsedModel,
+    rawBaseUrls,
+    lastBaseUrlsUpdate,
+    rawDisabledProviders,
+    rawMints,
+    rawInfo,
+    rawLastModelsUpdate,
+    rawCachedTokens,
+    rawApiKeys,
+    rawChildKeys,
+    rawRoutstr21Models,
+    rawCachedReceiveTokens
+  ] = await Promise.all([
+    driver.getItem(
+      SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
+      {}
     ),
-    lastUsedModel: driver.getItem(
-      SDK_STORAGE_KEYS.LAST_USED_MODEL,
-      null
+    driver.getItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, null),
+    driver.getItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, []),
+    driver.getItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, null),
+    driver.getItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, []),
+    driver.getItem(
+      SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
+      {}
     ),
-    baseUrlsList: driver.getItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, []).map((url) => normalizeBaseUrl(url)),
-    lastBaseUrlsUpdate: driver.getItem(
-      SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE,
-      null
+    driver.getItem(
+      SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS,
+      {}
     ),
-    disabledProviders: driver.getItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, []).map((url) => normalizeBaseUrl(url)),
-    mintsFromAllProviders: Object.fromEntries(
-      Object.entries(
-        driver.getItem(
-          SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
-          {}
-        )
-      ).map(([baseUrl, mints]) => [
-        normalizeBaseUrl(baseUrl),
-        mints.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
-      ])
+    driver.getItem(
+      SDK_STORAGE_KEYS.LAST_MODELS_UPDATE,
+      {}
     ),
-    infoFromAllProviders: Object.fromEntries(
-      Object.entries(
-        driver.getItem(
-          SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS,
-          {}
-        )
-      ).map(([baseUrl, info]) => [normalizeBaseUrl(baseUrl), info])
-    ),
-    lastModelsUpdate: Object.fromEntries(
-      Object.entries(
-        driver.getItem(
-          SDK_STORAGE_KEYS.LAST_MODELS_UPDATE,
-          {}
-        )
-      ).map(([baseUrl, timestamp]) => [normalizeBaseUrl(baseUrl), timestamp])
-    ),
-    cachedTokens: driver.getItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, []).map((entry) => ({
-      ...entry,
-      baseUrl: normalizeBaseUrl(entry.baseUrl),
-      balance: typeof entry.balance === "number" ? entry.balance : getTokenBalance(entry.token),
-      lastUsed: entry.lastUsed ?? null
-    })),
-    apiKeys: driver.getItem(SDK_STORAGE_KEYS.API_KEYS, []).map((entry) => ({
-      ...entry,
-      baseUrl: normalizeBaseUrl(entry.baseUrl),
-      balance: entry.balance ?? 0,
-      lastUsed: entry.lastUsed ?? null
-    })),
-    childKeys: driver.getItem(SDK_STORAGE_KEYS.CHILD_KEYS, []).map((entry) => ({
-      parentBaseUrl: normalizeBaseUrl(entry.parentBaseUrl),
-      childKey: entry.childKey,
-      balance: entry.balance ?? 0,
-      balanceLimit: entry.balanceLimit,
-      validityDate: entry.validityDate,
-      createdAt: entry.createdAt ?? Date.now()
-    })),
+    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.ROUTSTR21_MODELS, []),
+    driver.getItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, [])
+  ]);
+  const modelsFromAllProviders = Object.fromEntries(
+    Object.entries(rawModels).map(([baseUrl, models]) => [
+      normalizeBaseUrl(baseUrl),
+      models
+    ])
+  );
+  const baseUrlsList = rawBaseUrls.map((url) => normalizeBaseUrl(url));
+  const disabledProviders = rawDisabledProviders.map(
+    (url) => normalizeBaseUrl(url)
+  );
+  const mintsFromAllProviders = Object.fromEntries(
+    Object.entries(rawMints).map(([baseUrl, mints]) => [
+      normalizeBaseUrl(baseUrl),
+      mints.map((mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint)
+    ])
+  );
+  const infoFromAllProviders = Object.fromEntries(
+    Object.entries(rawInfo).map(([baseUrl, info]) => [
+      normalizeBaseUrl(baseUrl),
+      info
+    ])
+  );
+  const lastModelsUpdate = Object.fromEntries(
+    Object.entries(rawLastModelsUpdate).map(([baseUrl, timestamp]) => [
+      normalizeBaseUrl(baseUrl),
+      timestamp
+    ])
+  );
+  const cachedTokens = rawCachedTokens.map((entry) => ({
+    ...entry,
+    baseUrl: normalizeBaseUrl(entry.baseUrl),
+    balance: typeof entry.balance === "number" ? entry.balance : getTokenBalance(entry.token),
+    lastUsed: entry.lastUsed ?? null
+  }));
+  const apiKeys = rawApiKeys.map((entry) => ({
+    ...entry,
+    baseUrl: normalizeBaseUrl(entry.baseUrl),
+    balance: entry.balance ?? 0,
+    lastUsed: entry.lastUsed ?? null
+  }));
+  const childKeys = rawChildKeys.map((entry) => ({
+    parentBaseUrl: normalizeBaseUrl(entry.parentBaseUrl),
+    childKey: entry.childKey,
+    balance: entry.balance ?? 0,
+    balanceLimit: entry.balanceLimit,
+    validityDate: entry.validityDate,
+    createdAt: entry.createdAt ?? Date.now()
+  }));
+  const routstr21Models = rawRoutstr21Models;
+  const cachedReceiveTokens = rawCachedReceiveTokens.map((entry) => ({
+    token: entry.token,
+    amount: entry.amount,
+    unit: entry.unit || "sat",
+    createdAt: entry.createdAt ?? Date.now()
+  }));
+  return vanilla.createStore((set, get) => ({
+    modelsFromAllProviders,
+    lastUsedModel,
+    baseUrlsList,
+    lastBaseUrlsUpdate,
+    disabledProviders,
+    mintsFromAllProviders,
+    infoFromAllProviders,
+    lastModelsUpdate,
+    cachedTokens,
+    apiKeys,
+    childKeys,
+    routstr21Models,
+    cachedReceiveTokens,
     setModelsFromAllProviders: (value) => {
       const normalized = {};
       for (const [baseUrl, models] of Object.entries(value)) {
         normalized[normalizeBaseUrl(baseUrl)] = models;
       }
-      driver.setItem(SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS, normalized);
+      void driver.setItem(
+        SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
+        normalized
+      );
       set({ modelsFromAllProviders: normalized });
     },
     setLastUsedModel: (value) => {
-      driver.setItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, value);
+      void driver.setItem(SDK_STORAGE_KEYS.LAST_USED_MODEL, value);
       set({ lastUsedModel: value });
     },
     setBaseUrlsList: (value) => {
       const normalized = value.map((url) => normalizeBaseUrl(url));
-      driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
+      void driver.setItem(SDK_STORAGE_KEYS.BASE_URLS_LIST, normalized);
       set({ baseUrlsList: normalized });
     },
     setBaseUrlsLastUpdate: (value) => {
-      driver.setItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, value);
+      void driver.setItem(SDK_STORAGE_KEYS.LAST_BASE_URLS_UPDATE, value);
       set({ lastBaseUrlsUpdate: value });
     },
     setDisabledProviders: (value) => {
       const normalized = value.map((url) => normalizeBaseUrl(url));
-      driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
+      void driver.setItem(SDK_STORAGE_KEYS.DISABLED_PROVIDERS, normalized);
       set({ disabledProviders: normalized });
     },
     setMintsFromAllProviders: (value) => {
@@ -3061,7 +3781,10 @@ var createSdkStore = ({ driver }) => {
           (mint) => mint.endsWith("/") ? mint.slice(0, -1) : mint
         );
       }
-      driver.setItem(SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS, normalized);
+      void driver.setItem(
+        SDK_STORAGE_KEYS.MINTS_FROM_ALL_PROVIDERS,
+        normalized
+      );
       set({ mintsFromAllProviders: normalized });
     },
     setInfoFromAllProviders: (value) => {
@@ -3069,7 +3792,7 @@ var createSdkStore = ({ driver }) => {
       for (const [baseUrl, info] of Object.entries(value)) {
         normalized[normalizeBaseUrl(baseUrl)] = info;
       }
-      driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
+      void driver.setItem(SDK_STORAGE_KEYS.INFO_FROM_ALL_PROVIDERS, normalized);
       set({ infoFromAllProviders: normalized });
     },
     setLastModelsUpdate: (value) => {
@@ -3077,7 +3800,7 @@ var createSdkStore = ({ driver }) => {
       for (const [baseUrl, timestamp] of Object.entries(value)) {
         normalized[normalizeBaseUrl(baseUrl)] = timestamp;
       }
-      driver.setItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE, normalized);
+      void driver.setItem(SDK_STORAGE_KEYS.LAST_MODELS_UPDATE, normalized);
       set({ lastModelsUpdate: normalized });
     },
     setCachedTokens: (value) => {
@@ -3089,7 +3812,7 @@ var createSdkStore = ({ driver }) => {
           balance: typeof entry.balance === "number" ? entry.balance : getTokenBalance(entry.token),
           lastUsed: entry.lastUsed ?? null
         }));
-        driver.setItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, normalized);
+        void driver.setItem(SDK_STORAGE_KEYS.LOCAL_CASHU_TOKENS, normalized);
         return { cachedTokens: normalized };
       });
     },
@@ -3102,7 +3825,7 @@ var createSdkStore = ({ driver }) => {
           balance: entry.balance ?? 0,
           lastUsed: entry.lastUsed ?? null
         }));
-        driver.setItem(SDK_STORAGE_KEYS.API_KEYS, normalized);
+        void driver.setItem(SDK_STORAGE_KEYS.API_KEYS, normalized);
         return { apiKeys: normalized };
       });
     },
@@ -3117,9 +3840,23 @@ var createSdkStore = ({ driver }) => {
           validityDate: entry.validityDate,
           createdAt: entry.createdAt ?? Date.now()
         }));
-        driver.setItem(SDK_STORAGE_KEYS.CHILD_KEYS, normalized);
+        void driver.setItem(SDK_STORAGE_KEYS.CHILD_KEYS, normalized);
         return { childKeys: normalized };
       });
+    },
+    setRoutstr21Models: (value) => {
+      void driver.setItem(SDK_STORAGE_KEYS.ROUTSTR21_MODELS, value);
+      set({ routstr21Models: value });
+    },
+    setCachedReceiveTokens: (value) => {
+      const normalized = value.map((entry) => ({
+        token: entry.token,
+        amount: entry.amount,
+        unit: entry.unit || "sat",
+        createdAt: entry.createdAt ?? Date.now()
+      }));
+      void driver.setItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, normalized);
+      set({ cachedReceiveTokens: normalized });
     }
   }));
 };
@@ -3147,7 +3884,9 @@ var createDiscoveryAdapterFromStore = (store) => ({
   getBaseUrlsList: () => store.getState().baseUrlsList,
   setBaseUrlsList: (urls) => store.getState().setBaseUrlsList(urls),
   getBaseUrlsLastUpdate: () => store.getState().lastBaseUrlsUpdate,
-  setBaseUrlsLastUpdate: (timestamp) => store.getState().setBaseUrlsLastUpdate(timestamp)
+  setBaseUrlsLastUpdate: (timestamp) => store.getState().setBaseUrlsLastUpdate(timestamp),
+  getRoutstr21Models: () => store.getState().routstr21Models,
+  setRoutstr21Models: (models) => store.getState().setRoutstr21Models(models)
 });
 var createStorageAdapterFromStore = (store) => ({
   getToken: (baseUrl) => {
@@ -3192,10 +3931,21 @@ var createStorageAdapterFromStore = (store) => ({
     );
     store.getState().setCachedTokens(next);
   },
-  getPendingTokenDistribution: () => {
-    const tokens = store.getState().cachedTokens;
+  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 = {};
-    for (const entry of tokens) {
+    for (const entry of apiKeys) {
       const sum = entry.balance || 0;
       if (sum > 0) {
         distributionMap[entry.baseUrl] = (distributionMap[entry.baseUrl] || 0) + sum;
@@ -3222,7 +3972,7 @@ var createStorageAdapterFromStore = (store) => ({
       (key) => key.baseUrl === normalized ? { ...key, lastUsed: Date.now() } : key
     );
     store.getState().setApiKeys(next);
-    return entry.key;
+    return entry;
   },
   setApiKey: (baseUrl, key) => {
     const normalized = normalizeBaseUrl(baseUrl);
@@ -3231,20 +3981,16 @@ var createStorageAdapterFromStore = (store) => ({
       (entry) => entry.baseUrl === normalized
     );
     if (existingIndex !== -1) {
-      const next = keys.map(
-        (entry) => entry.baseUrl === normalized ? { ...entry, key, lastUsed: Date.now() } : entry
-      );
-      store.getState().setApiKeys(next);
-    } else {
-      const next = [...keys];
-      next.push({
-        baseUrl: normalized,
-        key,
-        balance: 0,
-        lastUsed: Date.now()
-      });
-      store.getState().setApiKeys(next);
+      throw new Error(`ApiKey already exists for baseUrl: ${normalized}`);
     }
+    const next = [...keys];
+    next.push({
+      baseUrl: normalized,
+      key,
+      balance: 0,
+      lastUsed: Date.now()
+    });
+    store.getState().setApiKeys(next);
   },
   updateApiKeyBalance: (baseUrl, balance) => {
     const normalized = normalizeBaseUrl(baseUrl);
@@ -3254,6 +4000,11 @@ var createStorageAdapterFromStore = (store) => ({
     );
     store.getState().setApiKeys(next);
   },
+  removeApiKey: (baseUrl) => {
+    const normalized = normalizeBaseUrl(baseUrl);
+    const next = store.getState().apiKeys.filter((entry) => entry.baseUrl !== normalized);
+    store.getState().setApiKeys(next);
+  },
   getAllApiKeys: () => {
     return store.getState().apiKeys.map((entry) => ({
       baseUrl: entry.baseUrl,
@@ -3329,6 +4080,12 @@ var createStorageAdapterFromStore = (store) => ({
       validityDate: entry.validityDate,
       createdAt: entry.createdAt
     }));
+  },
+  getCachedReceiveTokens: () => {
+    return store.getState().cachedReceiveTokens;
+  },
+  setCachedReceiveTokens: (tokens) => {
+    store.getState().setCachedReceiveTokens(tokens);
   }
 });
 var createProviderRegistryFromStore = (store) => ({
@@ -3379,12 +4136,19 @@ var isNode = () => {
   }
 };
 var defaultDriver = null;
+var isBun2 = () => {
+  return typeof process.versions.bun !== "undefined";
+};
 var getDefaultSdkDriver = () => {
   if (defaultDriver) return defaultDriver;
   if (isBrowser()) {
     defaultDriver = localStorageDriver;
     return defaultDriver;
   }
+  if (isBun2()) {
+    defaultDriver = createMemoryDriver();
+    return defaultDriver;
+  }
   if (isNode()) {
     defaultDriver = createSqliteDriver();
     return defaultDriver;
@@ -3392,16 +4156,16 @@ var getDefaultSdkDriver = () => {
   defaultDriver = createMemoryDriver();
   return defaultDriver;
 };
-var defaultStore = null;
+var defaultStorePromise = null;
 var getDefaultSdkStore = () => {
-  if (!defaultStore) {
-    defaultStore = createSdkStore({ driver: getDefaultSdkDriver() });
+  if (!defaultStorePromise) {
+    defaultStorePromise = createSdkStore({ driver: getDefaultSdkDriver() });
   }
-  return defaultStore;
+  return defaultStorePromise;
 };
-var getDefaultDiscoveryAdapter = () => createDiscoveryAdapterFromStore(getDefaultSdkStore());
-var getDefaultStorageAdapter = () => createStorageAdapterFromStore(getDefaultSdkStore());
-var getDefaultProviderRegistry = () => createProviderRegistryFromStore(getDefaultSdkStore());
+var getDefaultDiscoveryAdapter = async () => createDiscoveryAdapterFromStore(await getDefaultSdkStore());
+var getDefaultStorageAdapter = async () => createStorageAdapterFromStore(await getDefaultSdkStore());
+var getDefaultProviderRegistry = async () => createProviderRegistryFromStore(await getDefaultSdkStore());
 
 // routeRequests.ts
 async function routeRequests(options) {
@@ -3496,6 +4260,7 @@ async function routeRequests(options) {
     if (maxTokens !== void 0) {
       proxiedBody.max_tokens = maxTokens;
     }
+    console.log(modelId);
     response = await client.routeRequest({
       path,
       method: "POST",
@@ -3553,9 +4318,13 @@ exports.SDK_STORAGE_KEYS = SDK_STORAGE_KEYS;
 exports.StreamProcessor = StreamProcessor;
 exports.StreamingError = StreamingError;
 exports.TokenOperationError = TokenOperationError;
+exports.createDiscoveryAdapterFromStore = createDiscoveryAdapterFromStore;
+exports.createIndexedDBDriver = createIndexedDBDriver;
 exports.createMemoryDriver = createMemoryDriver;
+exports.createProviderRegistryFromStore = createProviderRegistryFromStore;
 exports.createSdkStore = createSdkStore;
 exports.createSqliteDriver = createSqliteDriver;
+exports.createStorageAdapterFromStore = createStorageAdapterFromStore;
 exports.filterBaseUrlsForTor = filterBaseUrlsForTor;
 exports.getDefaultDiscoveryAdapter = getDefaultDiscoveryAdapter;
 exports.getDefaultProviderRegistry = getDefaultProviderRegistry;