@routstr/sdk 0.3.3 → 0.3.5

package/dist/client/index.mjs

@@ -3,6 +3,19 @@ import { createStore } from 'zustand/vanilla';
 import { Transform } from 'stream';
 import { StringDecoder } from 'string_decoder';
 
+// core/types.ts
+function makeConsoleLogger(prefix) {
+  const fmt = (args) => prefix ? [prefix, ...args] : args;
+  return {
+    log: (...args) => console.log(...fmt(args)),
+    warn: (...args) => console.warn(...fmt(args)),
+    error: (...args) => console.error(...fmt(args)),
+    debug: (...args) => console.log(...fmt(args)),
+    child: (p) => makeConsoleLogger(prefix ? `${prefix}:${p}` : p)
+  };
+}
+var consoleLogger = makeConsoleLogger();
+
 // core/errors.ts
 var InsufficientBalanceError = class extends Error {
   constructor(required, available, maxMintBalance = 0, maxMintUrl = "", customMessage) {
@@ -102,14 +115,16 @@ function selectMintWithBalance(balances, units, amount, excludeMints = []) {
   return { selectedMintUrl: null, selectedMintBalance: 0 };
 }
 var CashuSpender = class {
-  constructor(walletAdapter, storageAdapter, _providerRegistry, balanceManager) {
+  constructor(walletAdapter, storageAdapter, _providerRegistry, balanceManager, logger) {
     this.walletAdapter = walletAdapter;
     this.storageAdapter = storageAdapter;
     this._providerRegistry = _providerRegistry;
     this.balanceManager = balanceManager;
+    this.logger = (logger ?? consoleLogger).child("CashuSpender");
   }
   _isBusy = false;
   debugLevel = "WARN";
+  logger;
   async receiveToken(token) {
     try {
       const result = await this.walletAdapter.receiveToken(token);
@@ -205,13 +220,13 @@ var CashuSpender = class {
     if (levelPriority[level] >= levelPriority[this.debugLevel]) {
       switch (level) {
         case "DEBUG":
-          console.log(...args);
+          this.logger.log(...args);
           break;
         case "WARN":
-          console.warn(...args);
+          this.logger.warn(...args);
           break;
         case "ERROR":
-          console.error(...args);
+          this.logger.error(...args);
           break;
       }
     }
@@ -559,19 +574,50 @@ var CashuSpender = class {
         apiKeyEntry.baseUrl
       );
       if (apiKeyEntryFull && this.balanceManager) {
+        try {
+          const balanceResult = await this.balanceManager.getTokenBalance(
+            apiKeyEntryFull.key,
+            apiKeyEntry.baseUrl
+          );
+          if (balanceResult.isInvalidApiKey) {
+            this.storageAdapter.removeApiKey(apiKeyEntry.baseUrl);
+            results.push({
+              baseUrl: apiKeyEntry.baseUrl,
+              success: true
+            });
+            continue;
+          }
+          if (balanceResult.amount >= 0) {
+            const balanceSat = balanceResult.unit === "msat" ? Math.floor(balanceResult.amount / 1e3) : balanceResult.amount;
+            this.storageAdapter.updateApiKeyBalance(
+              apiKeyEntry.baseUrl,
+              balanceSat
+            );
+          }
+        } catch {
+        }
+        const refreshedEntry = this.storageAdapter.getApiKey(
+          apiKeyEntry.baseUrl
+        );
+        if (!refreshedEntry) continue;
         const refundResult = await this.balanceManager.refundApiKey({
           mintUrl,
           baseUrl: apiKeyEntry.baseUrl,
-          apiKey: apiKeyEntryFull.key,
+          apiKey: refreshedEntry.key,
           forceRefund
         });
         if (refundResult.success) {
           this.storageAdapter.removeApiKey(apiKeyEntry.baseUrl);
         } else {
-          this.storageAdapter.updateApiKeyBalance(
-            apiKeyEntry.baseUrl,
-            apiKeyEntry.amount
+          const currentEntry = this.storageAdapter.getApiKey(
+            apiKeyEntry.baseUrl
           );
+          if (currentEntry) {
+            this.storageAdapter.updateApiKeyBalance(
+              apiKeyEntry.baseUrl,
+              currentEntry.balance
+            );
+          }
         }
         results.push({
           baseUrl: apiKeyEntry.baseUrl,
@@ -638,10 +684,11 @@ var CashuSpender = class {
 
 // wallet/BalanceManager.ts
 var BalanceManager = class _BalanceManager {
-  constructor(walletAdapter, storageAdapter, providerRegistry, cashuSpender) {
+  constructor(walletAdapter, storageAdapter, providerRegistry, cashuSpender, logger) {
     this.walletAdapter = walletAdapter;
     this.storageAdapter = storageAdapter;
     this.providerRegistry = providerRegistry;
+    this.logger = (logger ?? consoleLogger).child("BalanceManager");
     if (cashuSpender) {
       this.cashuSpender = cashuSpender;
     } else {
@@ -658,6 +705,7 @@ var BalanceManager = class _BalanceManager {
   providerWalletOps = /* @__PURE__ */ new Map();
   /** Cooldown (ms) between opposite operations on the same provider */
   static PROVIDER_WALLET_COOLDOWN_MS = 1e4;
+  logger;
   /**
    * Check whether a wallet operation (topup/refund) may run for a provider.
    * Returns the reason when blocked.
@@ -732,7 +780,7 @@ var BalanceManager = class _BalanceManager {
     const { mintUrl, baseUrl, apiKey, forceRefund } = options;
     const guard = this._canRunProviderWalletOperation(baseUrl, "refund");
     if (!guard.allowed) {
-      console.log(`[BalanceManager] Skipping refund for ${baseUrl} - ${guard.reason}`);
+      this.logger.log(`Skipping refund for ${baseUrl} - ${guard.reason}`);
       return { success: false, message: guard.reason };
     }
     this._beginProviderWalletOperation(baseUrl, "refund");
@@ -752,9 +800,7 @@ var BalanceManager = class _BalanceManager {
       if (apiKeyEntry?.lastUsed) {
         const fiveMinutesAgo = Date.now() - 5 * 60 * 1e3;
         if (apiKeyEntry.lastUsed > fiveMinutesAgo) {
-          console.log(
-            `[BalanceManager] Skipping refund for ${baseUrl} - used ${Math.round((Date.now() - apiKeyEntry.lastUsed) / 1e3)}s ago`
-          );
+          this.logger.log(`Skipping refund for ${baseUrl} - used ${Math.round((Date.now() - apiKeyEntry.lastUsed) / 1e3)}s ago`);
           return {
             success: false,
             message: "API key was used recently, skipping refund"
@@ -780,7 +826,8 @@ var BalanceManager = class _BalanceManager {
         };
       }
       if (fetchResult.error === "No balance to refund") {
-        return { success: false, message: "No balance to refund" };
+        this.storageAdapter.removeApiKey(baseUrl);
+        return { success: true, message: "No balance to refund, key cleaned up" };
       }
       const receiveResult = await this.cashuSpender.receiveToken(
         fetchResult.token
@@ -796,7 +843,7 @@ var BalanceManager = class _BalanceManager {
         requestId: fetchResult.requestId
       };
     } catch (error) {
-      console.error("[BalanceManager] API key refund error", error);
+      this.logger.error("API key refund error", error);
       return this._handleRefundError(error, mintUrl, fetchResult?.requestId);
     }
   }
@@ -848,7 +895,7 @@ var BalanceManager = class _BalanceManager {
       };
     } catch (error) {
       clearTimeout(timeoutId);
-      console.error("[BalanceManager.fetchRefundToken] Fetch error", error);
+      this.logger.error("fetchRefundToken fetch error", error);
       if (error instanceof Error) {
         if (error.name === "AbortError") {
           return {
@@ -874,7 +921,7 @@ var BalanceManager = class _BalanceManager {
     const { mintUrl, baseUrl, amount, token: providedToken } = options;
     const guard = this._canRunProviderWalletOperation(baseUrl, "topup");
     if (!guard.allowed) {
-      console.log(`[BalanceManager] Skipping topup for ${baseUrl} - ${guard.reason}`);
+      this.logger.log(`Skipping topup for ${baseUrl} - ${guard.reason}`);
       return { success: false, message: guard.reason };
     }
     this._beginProviderWalletOperation(baseUrl, "topup");
@@ -911,7 +958,7 @@ var BalanceManager = class _BalanceManager {
       cashuToken = tokenResult.token;
       const topUpResult = await this._postTopUp(baseUrl, apiKey, cashuToken);
       requestId = topUpResult.requestId;
-      console.log(topUpResult);
+      this.logger.log("topUpResult:", topUpResult);
       if (!topUpResult.success) {
         await this._recoverFailedTopUp(cashuToken);
         return {
@@ -927,10 +974,7 @@ var BalanceManager = class _BalanceManager {
         requestId
       };
     } catch (error) {
-      console.log(
-        "DEBUG",
-        `[TopuPU] topup: Topup result for ${baseUrl}: error=${error}`
-      );
+      this.logger.log(`topup error for ${baseUrl}: ${error}`);
       if (cashuToken) {
         await this._recoverFailedTopUp(cashuToken);
       }
@@ -947,13 +991,9 @@ var BalanceManager = class _BalanceManager {
       p2pkPubkey
     } = options;
     const adjustedAmount = Math.ceil(amount);
-    console.log(
-      `[BalanceManager.createProviderToken] Starting: baseUrl=${baseUrl}, mintUrl=${mintUrl}, amount=${amount}, adjustedAmount=${adjustedAmount}, retryCount=${retryCount}`
-    );
+    this.logger.log(`createProviderToken: baseUrl=${baseUrl} mintUrl=${mintUrl} amount=${amount} adjustedAmount=${adjustedAmount} retryCount=${retryCount}`);
     if (!adjustedAmount || isNaN(adjustedAmount)) {
-      console.error(
-        `[BalanceManager.createProviderToken] FAILURE: Invalid amount - amount=${amount}, adjustedAmount=${adjustedAmount}`
-      );
+      this.logger.error(`createProviderToken: invalid amount=${amount}`);
       return { success: false, error: "Invalid top up amount" };
     }
     const balanceState = await this.getBalanceState();
@@ -984,9 +1024,7 @@ var BalanceManager = class _BalanceManager {
           { url: "", balance: 0 }
         ).url
       );
-      console.error(
-        `[BalanceManager.createProviderToken] FAILURE: Insufficient balance - required=${adjustedAmount}, available=${totalMintBalance + targetProviderBalance}, totalMintBalance=${totalMintBalance}, targetProviderBalance=${targetProviderBalance}, refundableProviderBalance=${refundableProviderBalance}`
-      );
+      this.logger.error(`createProviderToken: insufficient balance required=${adjustedAmount} available=${totalMintBalance + targetProviderBalance} totalMint=${totalMintBalance} targetProvider=${targetProviderBalance}`);
       return { success: false, error: error.message };
     }
     const providerMints = baseUrl && this.providerRegistry ? this.providerRegistry.getProviderMints(baseUrl) : [];
@@ -1022,9 +1060,7 @@ var BalanceManager = class _BalanceManager {
           maxMintUrl = mintUrl2;
         }
       }
-      console.error(
-        `[BalanceManager.createProviderToken] FAILURE: No candidate mints found - requiredAmount=${requiredAmount}, totalMintBalance=${totalMintBalance}, maxBalance=${maxBalance}, maxMintUrl=${maxMintUrl}, providerMints=${JSON.stringify(providerMints)}`
-      );
+      this.logger.error(`createProviderToken: no candidate mints required=${requiredAmount} totalMint=${totalMintBalance} maxBalance=${maxBalance} maxMint=${maxMintUrl}`);
       const error = new InsufficientBalanceError(
         adjustedAmount,
         totalMintBalance,
@@ -1036,17 +1072,13 @@ var BalanceManager = class _BalanceManager {
     let lastError;
     for (const candidateMint of candidates) {
       try {
-        console.log(
-          `[BalanceManager.createProviderToken] Attempting mint: ${candidateMint}, amount: ${requiredAmount}`
-        );
+        this.logger.log(`createProviderToken: attempting mint=${candidateMint} amount=${requiredAmount}`);
         const token = await this.walletAdapter.sendToken(
           candidateMint,
           requiredAmount,
           p2pkPubkey
         );
-        console.log(
-          `[BalanceManager.createProviderToken] SUCCESS: Token created from mint ${candidateMint}, all mint balances: ${JSON.stringify(Object.fromEntries(Object.entries(balances).map(([mint, balance]) => [mint, getBalanceInSats(balance, units[mint])])))}`
-        );
+        this.logger.log(`createProviderToken: success from mint=${candidateMint}`);
         return {
           success: true,
           token,
@@ -1055,15 +1087,11 @@ var BalanceManager = class _BalanceManager {
         };
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        console.error(
-          `[BalanceManager.createProviderToken] FAILURE: Mint ${candidateMint} failed with error: ${errorMsg}`
-        );
+        this.logger.error(`createProviderToken: mint=${candidateMint} failed: ${errorMsg}`);
         if (error instanceof Error) {
           lastError = errorMsg;
           if (isNetworkErrorMessage(error.message)) {
-            console.warn(
-              `[BalanceManager.createProviderToken] Network error from ${candidateMint}, trying next mint...`
-            );
+            this.logger.warn(`createProviderToken: network error from ${candidateMint}, trying next mint...`);
             continue;
           }
         }
@@ -1073,9 +1101,7 @@ var BalanceManager = class _BalanceManager {
         };
       }
     }
-    console.error(
-      `[BalanceManager.createProviderToken] FAILURE: All candidate mints exhausted - lastError=${lastError}, candidates=${JSON.stringify(candidates)}`
-    );
+    this.logger.error(`createProviderToken: all candidate mints exhausted lastError=${lastError}`);
     return {
       success: false,
       error: lastError || "All candidate mints failed while creating top up token"
@@ -1190,7 +1216,7 @@ var BalanceManager = class _BalanceManager {
       return { success: true, requestId };
     } catch (error) {
       clearTimeout(timeoutId);
-      console.error("[BalanceManager._postTopUp] Fetch error", error);
+      this.logger.error("_postTopUp fetch error", error);
       if (error instanceof Error) {
         if (error.name === "AbortError") {
           return {
@@ -1216,10 +1242,7 @@ var BalanceManager = class _BalanceManager {
     try {
       await this.cashuSpender.receiveToken(cashuToken);
     } catch (error) {
-      console.error(
-        "[BalanceManager._recoverFailedTopUp] Failed to recover token",
-        error
-      );
+      this.logger.error("_recoverFailedTopUp: failed to recover token", error);
     }
   }
   /**
@@ -1272,9 +1295,9 @@ var BalanceManager = class _BalanceManager {
           apiKey: data.api_key
         };
       } else {
-        console.log(response.status);
+        this.logger.warn(`getTokenBalance: status=${response.status}`);
         const data = await response.json();
-        console.log("FAILED ", data);
+        this.logger.warn("getTokenBalance: FAILED", data);
         const isInvalidApiKey = response.status === 401 && data?.detail?.error?.code === "invalid_api_key" && data?.detail?.error?.message?.includes("proofs already spent");
         return {
           amount: -1,
@@ -1285,7 +1308,7 @@ var BalanceManager = class _BalanceManager {
         };
       }
     } catch (error) {
-      console.error("ERRORR IN RESTPONSE", error);
+      this.logger.error("getTokenBalance error", error);
     }
     return { amount: -1, reserved: 0, unit: "sat", apiKey: "" };
   }
@@ -1751,9 +1774,10 @@ function isInsecureHttpUrl(url) {
   return url.startsWith("http://");
 }
 var ProviderManager = class _ProviderManager {
-  constructor(providerRegistry, store) {
+  constructor(providerRegistry, store, logger) {
     this.providerRegistry = providerRegistry;
     this.instanceId = `pm_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
+    this.logger = (logger ?? consoleLogger).child(`ProviderManager:${this.instanceId}`);
     if (store) {
       this.store = store;
       this.hydrateFromStore();
@@ -1770,6 +1794,7 @@ var ProviderManager = class _ProviderManager {
   store = null;
   /** Instance ID for debugging */
   instanceId;
+  logger;
   /**
    * Hydrate in-memory state from persistent store
    */
@@ -1782,10 +1807,7 @@ var ProviderManager = class _ProviderManager {
     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}`);
+    this.logger.log(`Hydrated from store: failedProviders=${this.failedProviders.size} lastFailed=${this.lastFailed.size} providersOnCooldown=${this.providersOnCoolDown.length}`);
   }
   /**
    * Get instance ID for debugging
@@ -1805,9 +1827,7 @@ var ProviderManager = class _ProviderManager {
         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)`
-          );
+          this.logger.log(`Removing expired cooldown for ${url} (age: ${age}ms)`);
           this.failedProviders.delete(url);
           if (this.store) {
             this.store.getState().removeFailedProvider(url);
@@ -1818,9 +1838,7 @@ var ProviderManager = class _ProviderManager {
     );
     const after = this.providersOnCoolDown.length;
     if (before !== after) {
-      console.log(
-        `[cleanupExpiredCooldowns:${this.instanceId}] Cleaned up ${before - after} expired cooldown(s), ${after} remaining`
-      );
+      this.logger.log(`Cleaned up ${before - after} expired cooldown(s), ${after} remaining`);
     }
   }
   /**
@@ -1872,24 +1890,10 @@ 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}`
-    );
+    this.logger.log(`markFailed: ${baseUrl} lastFailure=${lastFailure} now=${now}`);
     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.logger.log(`markFailed: timeSinceLastFailure=${timeSinceLastFailure}ms withinCooldown=${timeSinceLastFailure < _ProviderManager.COOLDOWN_DURATION_MS}`);
     }
     this.lastFailed.set(baseUrl, now);
     this.failedProviders.add(baseUrl);
@@ -1897,38 +1901,23 @@ var ProviderManager = class _ProviderManager {
       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}`
-    );
+    this.logger.log(`markFailed: updated ${baseUrl} to ${now}, failedProviders=${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}`
-      );
+      this.logger.log(`markFailed: second failure 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`
-        );
+        this.logger.log(`markFailed: ${baseUrl} added to cooldown`);
       } else {
-        console.log(
-          `[markFailed:${this.instanceId}] Provider ${baseUrl} is already on cooldown`
-        );
+        this.logger.log(`markFailed: ${baseUrl} already on cooldown`);
       }
     } else {
       if (lastFailure === void 0) {
-        console.log(
-          `[markFailed:${this.instanceId}] First failure for ${baseUrl} - not adding to cooldown yet`
-        );
+        this.logger.log(`markFailed: first failure for ${baseUrl}`);
       } else {
-        console.log(
-          `[markFailed:${this.instanceId}] Failure outside cooldown window for ${baseUrl} (timeSinceLastFailure: ${now - lastFailure}ms)`
-        );
+        this.logger.log(`markFailed: failure outside cooldown window for ${baseUrl} (${now - lastFailure}ms ago)`);
       }
     }
   }
@@ -1985,25 +1974,12 @@ var ProviderManager = class _ProviderManager {
       const disabledProviders = new Set(
         this.providerRegistry.getDisabledProviders()
       );
-      console.log(
-        `[findNextBestProvider:${this.instanceId}] Starting search for model: ${modelId}`
-      );
-      console.log(
-        `[findNextBestProvider:${this.instanceId}] disabledProviders: ${[...disabledProviders]}`
-      );
-      console.log(
-        `[findNextBestProvider:${this.instanceId}] providersOnCooldown: ${this.providersOnCoolDown.map(([url]) => url)}`
-      );
+      this.logger.log(`findNextBestProvider: model=${modelId} disabled=${[...disabledProviders].length} onCooldown=${this.providersOnCoolDown.length}`);
       const allProviders = this.providerRegistry.getAllProvidersModels();
-      console.log(
-        `[findNextBestProvider:${this.instanceId}] Total providers in registry: ${Object.keys(allProviders).length}`
-      );
+      this.logger.log(`findNextBestProvider: total providers=${Object.keys(allProviders).length}`);
       const candidates = [];
       for (const [baseUrl, models] of Object.entries(allProviders)) {
         if (baseUrl === currentBaseUrl) {
-          console.log(
-            `[findNextBestProvider:${this.instanceId}] SKIP (current): ${baseUrl}`
-          );
           continue;
         }
         if (disabledProviders.has(baseUrl)) {
@@ -2029,7 +2005,7 @@ var ProviderManager = class _ProviderManager {
         return null;
       }
     } catch (error) {
-      console.error("Error finding next best provider:", error);
+      this.logger.error("findNextBestProvider error:", error);
       return null;
     }
   }
@@ -2156,16 +2132,9 @@ var ProviderManager = class _ProviderManager {
                     res.height
                   );
                   imageTokens += tokensFromImage;
-                  console.log("IMAGE INPUT RESOLUTION", {
-                    width: res.width,
-                    height: res.height,
-                    tokensFromImage
-                  });
+                  this.logger.log(`IMAGE INPUT RESOLUTION width=${res.width} height=${res.height} tokens=${tokensFromImage}`);
                 } else {
-                  console.log(
-                    "IMAGE INPUT RESOLUTION",
-                    "unknown (unsupported format or parse failure)"
-                  );
+                  this.logger.log("IMAGE INPUT RESOLUTION: unknown format");
                 }
               }
             }
@@ -2198,7 +2167,7 @@ var ProviderManager = class _ProviderManager {
       const totalEstimatedCosts = (promptCosts + completionCost) * 1.05;
       return totalEstimatedCosts;
     } catch (e) {
-      console.error(e);
+      this.logger.error("getRequiredSatsForModel error:", e);
       return 0;
     }
   }
@@ -3695,6 +3664,7 @@ var RoutstrClient = class {
     this.walletAdapter = walletAdapter;
     this.storageAdapter = storageAdapter;
     this.providerRegistry = providerRegistry;
+    this.logger = (options.logger ?? consoleLogger).child("RoutstrClient");
     this.balanceManager = new BalanceManager(
       walletAdapter,
       storageAdapter,
@@ -3711,7 +3681,7 @@ var RoutstrClient = class {
     this.mode = mode;
     this.usageTrackingDriver = options.usageTrackingDriver;
     this.sdkStore = options.sdkStore;
-    this.providerManager = options.providerManager ?? new ProviderManager(providerRegistry, this.sdkStore);
+    this.providerManager = options.providerManager ?? new ProviderManager(providerRegistry, this.sdkStore, this.logger);
   }
   cashuSpender;
   balanceManager;
@@ -3722,6 +3692,7 @@ var RoutstrClient = class {
   debugLevel = "WARN";
   usageTrackingDriver;
   sdkStore;
+  logger;
   /**
    * Get the current client mode
    */
@@ -3743,13 +3714,13 @@ var RoutstrClient = class {
     if (levelPriority[level] >= levelPriority[this.debugLevel]) {
       switch (level) {
         case "DEBUG":
-          console.log(...args);
+          this.logger.log(...args);
           break;
         case "WARN":
-          console.warn(...args);
+          this.logger.warn(...args);
           break;
         case "ERROR":
-          console.error(...args);
+          this.logger.error(...args);
           break;
       }
     }
@@ -4353,7 +4324,7 @@ var RoutstrClient = class {
         tryNextProvider = true;
       }
     }
-    if ((status === 401 || status === 403 || status === 413 || status === 400 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504 || status === 521) && !tryNextProvider) {
+    if ((status === 401 || status === 403 || status === 404 || status === 413 || status === 400 || status === 429 || status === 500 || status === 502 || status === 503 || status === 504 || status === 521) && !tryNextProvider) {
       this._log(
         "DEBUG",
         `[RoutstrClient] _handleErrorResponse: Status ${status} (${status === 429 ? "rate limited" : "auth/server error"}), attempting refund for ${baseUrl}, mode=${this.mode}`