@routstr/sdk 0.2.6 → 0.2.8

package/dist/client/index.js

@@ -1,5 +1,6 @@
 'use strict';
 
+var cashuTs = require('@cashu/cashu-ts');
 var vanilla = require('zustand/vanilla');
 var stream = require('stream');
 
@@ -101,8 +102,6 @@ function selectMintWithBalance(balances, units, amount, excludeMints = []) {
   }
   return { selectedMintUrl: null, selectedMintBalance: 0 };
 }
-
-// wallet/CashuSpender.ts
 var CashuSpender = class {
   constructor(walletAdapter, storageAdapter, _providerRegistry, balanceManager) {
     this.walletAdapter = walletAdapter;
@@ -113,23 +112,43 @@ var CashuSpender = class {
   _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()
-          }
-        ]);
+    try {
+      const result = await this.walletAdapter.receiveToken(token);
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("Failed to fetch mint")) {
+        const cachedTokens = this.storageAdapter.getCachedReceiveTokens();
+        const existingIndex = cachedTokens.findIndex((t) => t.token === token);
+        if (existingIndex === -1) {
+          const { amount: amount2, unit: unit2 } = this._decodeTokenAmount(token);
+          this.storageAdapter.setCachedReceiveTokens([
+            ...cachedTokens,
+            {
+              token,
+              amount: amount2,
+              unit: unit2,
+              createdAt: Date.now()
+            }
+          ]);
+        }
       }
+      const { amount, unit } = this._decodeTokenAmount(token);
+      return { success: false, amount, unit, message: errorMessage };
+    }
+  }
+  _decodeTokenAmount(token) {
+    try {
+      const decoded = cashuTs.getDecodedToken(token);
+      const amount = decoded.proofs.reduce(
+        (acc, proof) => acc + proof.amount,
+        0
+      );
+      const unit = decoded.unit || "sat";
+      return { amount, unit };
+    } catch {
+      return { amount: 0, unit: "sat" };
     }
-    return result;
   }
   async _getBalanceState() {
     if (this.balanceManager) {
@@ -449,8 +468,9 @@ var CashuSpender = class {
     return null;
   }
   /**
-   * Refund all xcashu tokens from storage and increment tryCounts on failure.
-   * Reuses receiveToken from BalanceManager/CashuSpender for receiving refunds.
+   * Refund all xcashu tokens from storage by calling the provider's refund endpoint.
+   * The xcashu token acts as an API key to claim the refund, and the response contains
+   * the actual refunded Cashu token which is then received into the wallet.
    * @param mintUrl - The mint URL for receiving tokens
    * @param excludeBaseUrls - Base URLs to exclude from refund (optional)
    * @returns Results for each xcashu token refund attempt
@@ -463,7 +483,20 @@ var CashuSpender = class {
       if (excludedUrls.has(baseUrl)) continue;
       for (const xcashuToken of tokens) {
         try {
-          const receiveResult = await this.receiveToken(xcashuToken.token);
+          if (!this.balanceManager) {
+            throw new Error("BalanceManager not available for xcashu refund");
+          }
+          const fetchResult = await this.balanceManager.fetchRefundToken(
+            baseUrl,
+            xcashuToken.token,
+            true
+          );
+          if (!fetchResult.success || !fetchResult.token) {
+            throw new Error(
+              fetchResult.error || "Failed to fetch refund token from provider"
+            );
+          }
+          const receiveResult = await this.receiveToken(fetchResult.token);
           if (receiveResult.success) {
             this.storageAdapter.removeXcashuToken(baseUrl, xcashuToken.token);
             results.push({
@@ -478,7 +511,10 @@ var CashuSpender = class {
           } else {
             const currentTryCount = xcashuToken.tryCount ?? 0;
             const newTryCount = currentTryCount + 1;
-            this.storageAdapter.updateXcashuTokenTryCount(xcashuToken.token, newTryCount);
+            this.storageAdapter.updateXcashuTokenTryCount(
+              xcashuToken.token,
+              newTryCount
+            );
             results.push({
               baseUrl,
               token: xcashuToken.token,
@@ -487,13 +523,16 @@ var CashuSpender = class {
             });
             this._log(
               "DEBUG",
-              `[CashuSpender] refundXcashuTokens: Failed to refund xcashu token for ${baseUrl}, incremented tryCount to ${newTryCount}`
+              `[CashuSpender] refundXcashuTokens: Failed to receive refund token for ${baseUrl}, incremented tryCount to ${newTryCount}: ${receiveResult.message}`
             );
           }
         } catch (error) {
           const currentTryCount = xcashuToken.tryCount ?? 0;
           const newTryCount = currentTryCount + 1;
-          this.storageAdapter.updateXcashuTokenTryCount(xcashuToken.token, newTryCount);
+          this.storageAdapter.updateXcashuTokenTryCount(
+            xcashuToken.token,
+            newTryCount
+          );
           const errorMessage = error instanceof Error ? error.message : String(error);
           results.push({
             baseUrl,
@@ -530,7 +569,10 @@ var CashuSpender = class {
         if (refundResult.success) {
           this.storageAdapter.removeApiKey(apiKeyEntry.baseUrl);
         } else {
-          this.storageAdapter.updateApiKeyBalance(apiKeyEntry.baseUrl, apiKeyEntry.amount);
+          this.storageAdapter.updateApiKeyBalance(
+            apiKeyEntry.baseUrl,
+            apiKeyEntry.amount
+          );
         }
         results.push({
           baseUrl: apiKeyEntry.baseUrl,
@@ -668,7 +710,7 @@ var BalanceManager = class {
     }
     let fetchResult;
     try {
-      fetchResult = await this._fetchRefundTokenWithApiKey(baseUrl, apiKey);
+      fetchResult = await this.fetchRefundToken(baseUrl, apiKey);
       if (!fetchResult.success) {
         return {
           success: false,
@@ -696,6 +738,7 @@ var BalanceManager = class {
       return {
         success: receiveResult.success,
         refundedAmount: totalAmountMsat,
+        message: receiveResult.message,
         requestId: fetchResult.requestId
       };
     } catch (error) {
@@ -704,9 +747,9 @@ var BalanceManager = class {
     }
   }
   /**
-   * Fetch refund token from provider API using API key authentication
+   * Fetch refund token from provider API using API key (or xcashu token) authentication
    */
-  async _fetchRefundTokenWithApiKey(baseUrl, apiKey) {
+  async fetchRefundToken(baseUrl, apiKeyOrToken, xCashu = false) {
     if (!baseUrl) {
       return {
         success: false,
@@ -720,12 +763,17 @@ var BalanceManager = class {
       controller.abort();
     }, 6e4);
     try {
+      const headers = {
+        "Content-Type": "application/json"
+      };
+      if (xCashu) {
+        headers["X-Cashu"] = apiKeyOrToken;
+      } else {
+        headers["Authorization"] = `Bearer ${apiKeyOrToken}`;
+      }
       const response = await fetch(url, {
         method: "POST",
-        headers: {
-          Authorization: `Bearer ${apiKey}`,
-          "Content-Type": "application/json"
-        },
+        headers,
         signal: controller.signal
       });
       clearTimeout(timeoutId);
@@ -746,10 +794,7 @@ var BalanceManager = class {
       };
     } catch (error) {
       clearTimeout(timeoutId);
-      console.error(
-        "[BalanceManager._fetchRefundTokenWithApiKey] Fetch error",
-        error
-      );
+      console.error("[BalanceManager.fetchRefundToken] Fetch error", error);
       if (error instanceof Error) {
         if (error.name === "AbortError") {
           return {
@@ -796,11 +841,7 @@ var BalanceManager = class {
         };
       }
       cashuToken = tokenResult.token;
-      const topUpResult = await this._postTopUp(
-        baseUrl,
-        apiKey,
-        cashuToken
-      );
+      const topUpResult = await this._postTopUp(baseUrl, apiKey, cashuToken);
       requestId = topUpResult.requestId;
       console.log(topUpResult);
       if (!topUpResult.success) {
@@ -1166,7 +1207,7 @@ var BalanceManager = class {
         console.log(response.status);
         const data = await response.json();
         console.log("FAILED ", data);
-        const isInvalidApiKey = response.status === 401 && data?.code === "invalid_api_key" && data?.message?.includes("proofs already spent");
+        const isInvalidApiKey = response.status === 401 && data?.detail?.error?.code === "invalid_api_key" && data?.detail?.error?.message?.includes("proofs already spent");
         return {
           amount: -1,
           reserved: data.reserved ?? 0,
@@ -1608,8 +1649,13 @@ function isInsecureHttpUrl(url) {
   return url.startsWith("http://");
 }
 var ProviderManager = class _ProviderManager {
-  constructor(providerRegistry) {
+  constructor(providerRegistry, store) {
     this.providerRegistry = providerRegistry;
+    this.instanceId = `pm_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    if (store) {
+      this.store = store;
+      this.hydrateFromStore();
+    }
   }
   failedProviders = /* @__PURE__ */ new Set();
   /** Track when each provider last failed (provider URL -> timestamp) */
@@ -1618,14 +1664,57 @@ var ProviderManager = class _ProviderManager {
   providersOnCoolDown = [];
   /** Cooldown duration in milliseconds (5 minutes) */
   static COOLDOWN_DURATION_MS = 5 * 60 * 1e3;
+  /** Optional persistent store for failure tracking */
+  store = null;
+  /** Instance ID for debugging */
+  instanceId;
+  /**
+   * Hydrate in-memory state from persistent store
+   */
+  hydrateFromStore() {
+    if (!this.store) return;
+    const state = this.store.getState();
+    this.failedProviders = new Set(state.failedProviders);
+    this.lastFailed = new Map(Object.entries(state.lastFailed));
+    const now = Date.now();
+    this.providersOnCoolDown = state.providersOnCooldown.filter(
+      (entry) => now - entry.timestamp < _ProviderManager.COOLDOWN_DURATION_MS
+    ).map((entry) => [entry.baseUrl, entry.timestamp]);
+    console.log(`[ProviderManager:${this.instanceId}] Hydrated from store:`);
+    console.log(`  failedProviders: ${this.failedProviders.size}`);
+    console.log(`  lastFailed: ${this.lastFailed.size}`);
+    console.log(`  providersOnCooldown: ${this.providersOnCoolDown.length}`);
+  }
+  /**
+   * Get instance ID for debugging
+   */
+  getInstanceId() {
+    return this.instanceId;
+  }
   /**
    * Clean up expired cooldown entries
    */
   cleanupExpiredCooldowns() {
     const now = Date.now();
+    const before = this.providersOnCoolDown.length;
     this.providersOnCoolDown = this.providersOnCoolDown.filter(
-      ([, timestamp]) => now - timestamp < _ProviderManager.COOLDOWN_DURATION_MS
+      ([url, timestamp]) => {
+        const age = now - timestamp;
+        const isExpired = age >= _ProviderManager.COOLDOWN_DURATION_MS;
+        if (isExpired) {
+          console.log(
+            `[cleanupExpiredCooldowns:${this.instanceId}] Removing expired cooldown for ${url} (age: ${age}ms, cooldown: ${_ProviderManager.COOLDOWN_DURATION_MS}ms)`
+          );
+        }
+        return !isExpired;
+      }
     );
+    const after = this.providersOnCoolDown.length;
+    if (before !== after) {
+      console.log(
+        `[cleanupExpiredCooldowns:${this.instanceId}] Cleaned up ${before - after} expired cooldown(s), ${after} remaining`
+      );
+    }
   }
   /**
    * Get the cooldown duration in milliseconds
@@ -1638,7 +1727,8 @@ var ProviderManager = class _ProviderManager {
    */
   isOnCooldown(baseUrl) {
     this.cleanupExpiredCooldowns();
-    return this.providersOnCoolDown.some(([url]) => url === baseUrl);
+    const result = this.providersOnCoolDown.some(([url]) => url === baseUrl);
+    return result;
   }
   /**
    * Get all providers currently on cooldown
@@ -1652,6 +1742,9 @@ var ProviderManager = class _ProviderManager {
    */
   resetFailedProviders() {
     this.failedProviders.clear();
+    if (this.store) {
+      this.store.getState().setFailedProviders([]);
+    }
   }
   /**
    * Get the last failed timestamp for a provider
@@ -1672,13 +1765,62 @@ var ProviderManager = class _ProviderManager {
   markFailed(baseUrl) {
     const now = Date.now();
     const lastFailure = this.lastFailed.get(baseUrl);
+    console.log(`[markFailed:${this.instanceId}] baseUrl: ${baseUrl}`);
+    console.log(
+      `[markFailed:${this.instanceId}] lastFailure from map: ${lastFailure}`
+    );
+    console.log(
+      `[markFailed:${this.instanceId}] current timestamp (now): ${now}`
+    );
+    console.log(
+      `[markFailed:${this.instanceId}] COOLDOWN_DURATION_MS: ${_ProviderManager.COOLDOWN_DURATION_MS}`
+    );
+    if (lastFailure !== void 0) {
+      const timeSinceLastFailure = now - lastFailure;
+      console.log(
+        `[markFailed:${this.instanceId}] timeSinceLastFailure: ${timeSinceLastFailure}ms`
+      );
+      console.log(
+        `[markFailed:${this.instanceId}] isWithinCooldownWindow: ${timeSinceLastFailure < _ProviderManager.COOLDOWN_DURATION_MS}`
+      );
+    }
     this.lastFailed.set(baseUrl, now);
     this.failedProviders.add(baseUrl);
+    if (this.store) {
+      this.store.getState().setLastFailedTimestamp(baseUrl, now);
+      this.store.getState().addFailedProvider(baseUrl);
+    }
+    console.log(
+      `[markFailed:${this.instanceId}] Updated lastFailed map for ${baseUrl} to ${now}`
+    );
+    console.log(
+      `[markFailed:${this.instanceId}] failedProviders set size: ${this.failedProviders.size}`
+    );
     if (lastFailure !== void 0 && now - lastFailure < _ProviderManager.COOLDOWN_DURATION_MS) {
+      console.log(
+        `[markFailed:${this.instanceId}] Second failure detected within cooldown window for ${baseUrl}`
+      );
       if (!this.isOnCooldown(baseUrl)) {
         this.providersOnCoolDown.push([baseUrl, now]);
+        if (this.store) {
+          this.store.getState().addProviderOnCooldown(baseUrl, now);
+        }
+        console.log(
+          `[markFailed:${this.instanceId}] Provider ${baseUrl} added to cooldown after second failure within 5 minutes`
+        );
+      } else {
         console.log(
-          `Provider ${baseUrl} added to cooldown after second failure within 5 minutes`
+          `[markFailed:${this.instanceId}] Provider ${baseUrl} is already on cooldown`
+        );
+      }
+    } else {
+      if (lastFailure === void 0) {
+        console.log(
+          `[markFailed:${this.instanceId}] First failure for ${baseUrl} - not adding to cooldown yet`
+        );
+      } else {
+        console.log(
+          `[markFailed:${this.instanceId}] Failure outside cooldown window for ${baseUrl} (timeSinceLastFailure: ${now - lastFailure}ms)`
         );
       }
     }
@@ -1690,18 +1832,27 @@ var ProviderManager = class _ProviderManager {
     this.providersOnCoolDown = this.providersOnCoolDown.filter(
       ([url]) => url !== baseUrl
     );
+    if (this.store) {
+      this.store.getState().removeProviderFromCooldown(baseUrl);
+    }
   }
   /**
    * Clear all cooldown tracking
    */
   clearCooldowns() {
     this.providersOnCoolDown = [];
+    if (this.store) {
+      this.store.getState().clearProvidersOnCooldown();
+    }
   }
   /**
    * Clear all failure tracking (lastFailed timestamps)
    */
   clearFailureHistory() {
     this.lastFailed.clear();
+    if (this.store) {
+      this.store.getState().setLastFailed({});
+    }
   }
   /**
    * Check if a provider has failed
@@ -2123,7 +2274,10 @@ var SDK_STORAGE_KEYS = {
   LAST_ROUTSTR21_MODELS_UPDATE: "lastRoutstr21ModelsUpdate",
   CACHED_RECEIVE_TOKENS: "cached_receive_tokens",
   USAGE_TRACKING: "usage_tracking",
-  CLIENT_IDS: "client_ids"
+  CLIENT_IDS: "client_ids",
+  FAILED_PROVIDERS: "failed_providers",
+  LAST_FAILED: "last_failed",
+  PROVIDERS_ON_COOLDOWN: "providers_on_cooldown"
 };
 
 // storage/usageTracking/indexedDB.ts
@@ -2770,6 +2924,9 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
   lastRoutstr21ModelsUpdate: null,
   cachedReceiveTokens: [],
   clientIds: [],
+  failedProviders: [],
+  lastFailed: {},
+  providersOnCooldown: [],
   setModelsFromAllProviders: (value) => {
     const normalized = {};
     for (const [baseUrl, models] of Object.entries(value)) {
@@ -2909,6 +3066,71 @@ var createEmptyStore = (driver) => vanilla.createStore((set, get) => ({
       void driver.setItem(SDK_STORAGE_KEYS.CLIENT_IDS, normalized);
       return { clientIds: normalized };
     });
+  },
+  // ========== Failure Tracking ==========
+  setFailedProviders: (value) => {
+    const normalized = value.map((url) => normalizeBaseUrl5(url));
+    void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, normalized);
+    set({ failedProviders: normalized });
+  },
+  addFailedProvider: (baseUrl) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().failedProviders;
+    if (!current.includes(normalized)) {
+      const updated = [...current, normalized];
+      void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, updated);
+      set({ failedProviders: updated });
+    }
+  },
+  removeFailedProvider: (baseUrl) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().failedProviders;
+    const updated = current.filter((url) => url !== normalized);
+    void driver.setItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, updated);
+    set({ failedProviders: updated });
+  },
+  setLastFailed: (value) => {
+    const normalized = {};
+    for (const [baseUrl, timestamp] of Object.entries(value)) {
+      normalized[normalizeBaseUrl5(baseUrl)] = timestamp;
+    }
+    void driver.setItem(SDK_STORAGE_KEYS.LAST_FAILED, normalized);
+    set({ lastFailed: normalized });
+  },
+  setLastFailedTimestamp: (baseUrl, timestamp) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().lastFailed;
+    const updated = { ...current, [normalized]: timestamp };
+    void driver.setItem(SDK_STORAGE_KEYS.LAST_FAILED, updated);
+    set({ lastFailed: updated });
+  },
+  setProvidersOnCooldown: (value) => {
+    const normalized = value.map((entry) => ({
+      baseUrl: normalizeBaseUrl5(entry.baseUrl),
+      timestamp: entry.timestamp
+    }));
+    void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, normalized);
+    set({ providersOnCooldown: normalized });
+  },
+  addProviderOnCooldown: (baseUrl, timestamp) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().providersOnCooldown;
+    if (!current.some((entry) => entry.baseUrl === normalized)) {
+      const updated = [...current, { baseUrl: normalized, timestamp }];
+      void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, updated);
+      set({ providersOnCooldown: updated });
+    }
+  },
+  removeProviderFromCooldown: (baseUrl) => {
+    const normalized = normalizeBaseUrl5(baseUrl);
+    const current = get().providersOnCooldown;
+    const updated = current.filter((entry) => entry.baseUrl !== normalized);
+    void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, updated);
+    set({ providersOnCooldown: updated });
+  },
+  clearProvidersOnCooldown: () => {
+    void driver.setItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, []);
+    set({ providersOnCooldown: [] });
   }
 }));
 var hydrateStoreFromDriver = async (store, driver) => {
@@ -2927,7 +3149,10 @@ var hydrateStoreFromDriver = async (store, driver) => {
     rawRoutstr21Models,
     rawLastRoutstr21ModelsUpdate,
     rawCachedReceiveTokens,
-    rawClientIds
+    rawClientIds,
+    rawFailedProviders,
+    rawLastFailed,
+    rawProvidersOnCooldown
   ] = await Promise.all([
     driver.getItem(
       SDK_STORAGE_KEYS.MODELS_FROM_ALL_PROVIDERS,
@@ -2958,7 +3183,10 @@ var hydrateStoreFromDriver = async (store, driver) => {
       null
     ),
     driver.getItem(SDK_STORAGE_KEYS.CACHED_RECEIVE_TOKENS, []),
-    driver.getItem(SDK_STORAGE_KEYS.CLIENT_IDS, [])
+    driver.getItem(SDK_STORAGE_KEYS.CLIENT_IDS, []),
+    driver.getItem(SDK_STORAGE_KEYS.FAILED_PROVIDERS, []),
+    driver.getItem(SDK_STORAGE_KEYS.LAST_FAILED, {}),
+    driver.getItem(SDK_STORAGE_KEYS.PROVIDERS_ON_COOLDOWN, [])
   ]);
   const modelsFromAllProviders = Object.fromEntries(
     Object.entries(rawModels).map(([baseUrl, models]) => [
@@ -3026,6 +3254,17 @@ var hydrateStoreFromDriver = async (store, driver) => {
     createdAt: entry.createdAt ?? Date.now(),
     lastUsed: entry.lastUsed ?? null
   }));
+  const failedProviders = rawFailedProviders.map((url) => normalizeBaseUrl5(url));
+  const lastFailed = Object.fromEntries(
+    Object.entries(rawLastFailed).map(([baseUrl, timestamp]) => [
+      normalizeBaseUrl5(baseUrl),
+      timestamp
+    ])
+  );
+  const providersOnCooldown = rawProvidersOnCooldown.map((entry) => ({
+    baseUrl: normalizeBaseUrl5(entry.baseUrl),
+    timestamp: entry.timestamp
+  }));
   store.setState({
     modelsFromAllProviders,
     lastUsedModel,
@@ -3041,7 +3280,10 @@ var hydrateStoreFromDriver = async (store, driver) => {
     routstr21Models,
     lastRoutstr21ModelsUpdate,
     cachedReceiveTokens,
-    clientIds
+    clientIds,
+    failedProviders,
+    lastFailed,
+    providersOnCooldown
   });
 };
 var createSdkStore = ({
@@ -3207,11 +3449,11 @@ var RoutstrClient = class {
       this.balanceManager
     );
     this.streamProcessor = new StreamProcessor();
-    this.providerManager = new ProviderManager(providerRegistry);
     this.alertLevel = alertLevel;
     this.mode = mode;
     this.usageTrackingDriver = options.usageTrackingDriver;
     this.sdkStore = options.sdkStore;
+    this.providerManager = options.providerManager ?? new ProviderManager(providerRegistry, this.sdkStore);
   }
   cashuSpender;
   balanceManager;
@@ -3674,19 +3916,19 @@ var RoutstrClient = class {
       `[RoutstrClient] _handleErrorResponse: Attempting to receive/restore token for ${baseUrl}`
     );
     if (params.token.startsWith("cashu")) {
-      const tryReceiveTokenResult = await this.cashuSpender.receiveToken(
+      const receiveResult = await this.cashuSpender.receiveToken(
         params.token
       );
-      if (tryReceiveTokenResult.success) {
+      if (receiveResult.success) {
         this._log(
           "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${tryReceiveTokenResult.amount}`
+          `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${receiveResult.amount}`
         );
         tryNextProvider = true;
       } else {
         this._log(
           "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Failed to receive token. `
+          `[RoutstrClient] _handleErrorResponse: Failed to receive token: ${receiveResult.message}`
         );
       }
     }
@@ -3696,23 +3938,18 @@ var RoutstrClient = class {
           "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}`
-            );
-            tryNextProvider = true;
-          } else
-            throw new ProviderError(
-              baseUrl,
-              status,
-              "xcashu refund failed",
-              requestId
-            );
-        } catch (error) {
-          this._log("ERROR", "[xcashu] Failed to receive refund token:", error);
+        const receiveResult = await this.cashuSpender.receiveToken(xCashuRefundToken);
+        if (receiveResult.success) {
+          this._log(
+            "DEBUG",
+            `[RoutstrClient] _handleErrorResponse: xcashu refund received, amount=${receiveResult.amount}`
+          );
+          tryNextProvider = true;
+        } else {
+          this._log(
+            "ERROR",
+            `[xcashu] Failed to receive refund token: ${receiveResult.message}`
+          );
           throw new ProviderError(
             baseUrl,
             status,
@@ -3741,6 +3978,10 @@ var RoutstrClient = class {
         const currentBalance = currentBalanceInfo.unit === "msat" ? currentBalanceInfo.amount / 1e3 : currentBalanceInfo.amount;
         const shortfall = Math.max(0, params.requiredSats - currentBalance);
         topupAmount = shortfall > 0 ? shortfall : params.requiredSats;
+        this._log(
+          "DEBUG",
+          `The shortfall is: ${shortfall}. requiredSats: ${params.requiredSats}. Current Balance: ${currentBalance} `
+        );
       } catch (e) {
         this._log(
           "WARN",
@@ -3870,6 +4111,20 @@ var RoutstrClient = class {
         tryNextProvider = true;
       }
     }
+    if (status === 401 && this.mode === "apikeys") {
+      this._log(
+        "DEBUG",
+        `[RoutstrClient] _handleErrorResponse: Checking balance for ${baseUrl}, key preview=${token}`
+      );
+      const latestBalanceInfo = await this.balanceManager.getTokenBalance(
+        token,
+        baseUrl
+      );
+      if (latestBalanceInfo.isInvalidApiKey) {
+        this.storageAdapter.removeApiKey(baseUrl);
+        tryNextProvider = true;
+      }
+    }
     if ((status === 401 || status === 403 || status === 413 || status === 400 || status === 500 || status === 502 || status === 503 || status === 504 || status === 521) && !tryNextProvider) {
       this._log(
         "DEBUG",
@@ -3880,13 +4135,13 @@ var RoutstrClient = class {
           "DEBUG",
           `[RoutstrClient] _handleErrorResponse: Attempting API key refund for ${baseUrl}, key preview=${token}`
         );
-        const initialBalance = await this.balanceManager.getTokenBalance(
+        const latestBalanceInfo = await this.balanceManager.getTokenBalance(
           token,
           baseUrl
         );
         this._log(
           "DEBUG",
-          `[RoutstrClient] _handleErrorResponse: Initial API key balance: ${initialBalance.amount}`
+          `[RoutstrClient] _handleErrorResponse: Initial API key balance: ${latestBalanceInfo.amount}`
         );
         const refundResult = await this.balanceManager.refundApiKey({
           mintUrl,
@@ -3898,7 +4153,7 @@ var RoutstrClient = class {
           "DEBUG",
           `[RoutstrClient] _handleErrorResponse: API key refund result: success=${refundResult.success}, message=${refundResult.message}`
         );
-        if (!refundResult.success && initialBalance.amount > 0) {
+        if (!refundResult.success && latestBalanceInfo.amount > 0) {
           throw new ProviderError(
             baseUrl,
             status,
@@ -3987,14 +4242,15 @@ var RoutstrClient = class {
     if (this.mode === "xcashu" && response) {
       const refundToken = response.headers.get("x-cashu") ?? void 0;
       if (refundToken) {
-        try {
-          const receiveResult = await this.cashuSpender.receiveToken(refundToken);
-          if (receiveResult.success) {
-            this.storageAdapter.removeXcashuToken(baseUrl, token);
-            satsSpent = initialTokenBalance - receiveResult.amount * (receiveResult.unit == "sat" ? 1 : 1e3);
-          }
-        } catch (error) {
-          this._log("ERROR", "[xcashu] Failed to receive refund token:", error);
+        const receiveResult = await this.cashuSpender.receiveToken(refundToken);
+        if (receiveResult.success) {
+          this.storageAdapter.removeXcashuToken(baseUrl, token);
+          satsSpent = initialTokenBalance - receiveResult.amount * (receiveResult.unit == "sat" ? 1 : 1e3);
+        } else {
+          this._log(
+            "ERROR",
+            `[xcashu] Failed to receive refund token: ${receiveResult.message}`
+          );
         }
       }
     } else if (this.mode === "apikeys") {
@@ -4038,7 +4294,6 @@ var RoutstrClient = class {
       try {
         const xcashuResults = await this.cashuSpender.refundXcashuTokens(mintUrl);
         this._log("DEBUG", "Refund xcashu tokens results:", xcashuResults);
-        const results = await this.cashuSpender.refundProviders(mintUrl);
       } catch (error) {
         this._log("ERROR", "Failed to refund providers:", error);
       }
@@ -4247,18 +4502,18 @@ var RoutstrClient = class {
           this.storageAdapter.setApiKey(baseUrl, spendResult2.token);
         } catch (error) {
           if (error instanceof Error && error.message.includes("ApiKey already exists")) {
-            const tryReceiveTokenResult = await this.cashuSpender.receiveToken(
+            const receiveResult = await this.cashuSpender.receiveToken(
               spendResult2.token
             );
-            if (tryReceiveTokenResult.success) {
+            if (receiveResult.success) {
               this._log(
                 "DEBUG",
-                `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${tryReceiveTokenResult.amount}`
+                `[RoutstrClient] _handleErrorResponse: Token restored successfully, amount=${receiveResult.amount}`
               );
             } else {
               this._log(
                 "DEBUG",
-                `[RoutstrClient] _handleErrorResponse: Token restore failed or not needed`
+                `[RoutstrClient] _handleErrorResponse: Token restore failed: ${receiveResult.message}`
               );
             }
             this._log(