@routstr/sdk 0.2.1 → 0.2.3

package/dist/index.mjs

@@ -726,7 +726,7 @@ 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");
+  return message.includes("NetworkError when attempting to fetch resource") || message.includes("Failed to fetch") || message.includes("Load failed") || message.includes("ERR_TLS_CERT_ALTNAME_INVALID") || message.includes("ERR_TLS_CERT_NOT_YET_VALID") || message.includes("ERR_TLS_CERT_EXPIRED") || message.includes("UNABLE_TO_VERIFY_LEAF_SIGNATURE") || message.includes("SELF_SIGNED_CERT_IN_CHAIN");
 }
 function getBalanceInSats(balance, unit) {
   return unit === "msat" ? balance / 1e3 : balance;
@@ -1016,7 +1016,26 @@ var CashuSpender = class {
       }
     }
     if (token && baseUrl) {
-      this.storageAdapter.setToken(baseUrl, token);
+      try {
+        this.storageAdapter.setToken(baseUrl, token);
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("Token already exists")) {
+          this._log(
+            "DEBUG",
+            `[CashuSpender] _spendInternal: Token already exists for ${baseUrl}, receiving newly created token and using existing`
+          );
+          const receiveResult = await this.receiveToken(token);
+          if (receiveResult.success) {
+            this._log(
+              "DEBUG",
+              `[CashuSpender] _spendInternal: Token restored successfully, amount=${receiveResult.amount}`
+            );
+          }
+          token = this.storageAdapter.getToken(baseUrl);
+        } else {
+          throw error;
+        }
+      }
     }
     this._logTransaction("spend", {
       amount: spentAmount,
@@ -1494,7 +1513,9 @@ var BalanceManager = class {
       p2pkPubkey
     } = options;
     const adjustedAmount = Math.ceil(amount);
+    console.log(`[BalanceManager.createProviderToken] Starting: 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}`);
       return { success: false, error: "Invalid top up amount" };
     }
     const balanceState = await this.getBalanceState();
@@ -1525,6 +1546,7 @@ var BalanceManager = class {
           { url: "", balance: 0 }
         ).url
       );
+      console.error(`[BalanceManager.createProviderToken] FAILURE: Insufficient balance - required=${adjustedAmount}, available=${totalMintBalance + targetProviderBalance}, totalMintBalance=${totalMintBalance}, targetProviderBalance=${targetProviderBalance}, refundableProviderBalance=${refundableProviderBalance}`);
       return { success: false, error: error.message };
     }
     if (targetProviderBalance >= adjustedAmount) {
@@ -1566,6 +1588,7 @@ var BalanceManager = class {
           maxMintUrl = mintUrl2;
         }
       }
+      console.error(`[BalanceManager.createProviderToken] FAILURE: No candidate mints found - requiredAmount=${requiredAmount}, totalMintBalance=${totalMintBalance}, maxBalance=${maxBalance}, maxMintUrl=${maxMintUrl}, providerMints=${JSON.stringify(providerMints)}`);
       const error = new InsufficientBalanceError(
         adjustedAmount,
         totalMintBalance,
@@ -1577,11 +1600,13 @@ var BalanceManager = class {
     let lastError;
     for (const candidateMint of candidates) {
       try {
+        console.log(`[BalanceManager.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}`);
         return {
           success: true,
           token,
@@ -1589,9 +1614,12 @@ var BalanceManager = class {
           amountSpent: requiredAmount
         };
       } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        console.error(`[BalanceManager.createProviderToken] FAILURE: Mint ${candidateMint} failed with error: ${errorMsg}`);
         if (error instanceof Error) {
-          lastError = error.message;
+          lastError = errorMsg;
           if (isNetworkErrorMessage(error.message)) {
+            console.warn(`[BalanceManager.createProviderToken] Network error from ${candidateMint}, trying next mint...`);
             continue;
           }
         }
@@ -1601,6 +1629,7 @@ var BalanceManager = class {
         };
       }
     }
+    console.error(`[BalanceManager.createProviderToken] FAILURE: All candidate mints exhausted - lastError=${lastError}, candidates=${JSON.stringify(candidates)}`);
     return {
       success: false,
       error: lastError || "All candidate mints failed while creating top up token"
@@ -1886,7 +1915,6 @@ var BalanceManager = class {
       });
       if (response.ok) {
         const data = await response.json();
-        console.log("TOKENA FASJDFAS", data);
         return {
           amount: data.balance,
           reserved: data.reserved ?? 0,
@@ -2315,22 +2343,101 @@ function calculateImageTokens(width, height, detail = "auto") {
 function isInsecureHttpUrl(url) {
   return url.startsWith("http://");
 }
-var ProviderManager = class {
+var ProviderManager = class _ProviderManager {
   constructor(providerRegistry) {
     this.providerRegistry = providerRegistry;
   }
   failedProviders = /* @__PURE__ */ new Set();
+  /** Track when each provider last failed (provider URL -> timestamp) */
+  lastFailed = /* @__PURE__ */ new Map();
+  /** Providers on cooldown: [provider_url, cooldown_started_timestamp][] */
+  providersOnCoolDown = [];
+  /** Cooldown duration in milliseconds (5 minutes) */
+  static COOLDOWN_DURATION_MS = 5 * 60 * 1e3;
+  /**
+   * Clean up expired cooldown entries
+   */
+  cleanupExpiredCooldowns() {
+    const now = Date.now();
+    this.providersOnCoolDown = this.providersOnCoolDown.filter(
+      ([, timestamp]) => now - timestamp < _ProviderManager.COOLDOWN_DURATION_MS
+    );
+  }
+  /**
+   * Get the cooldown duration in milliseconds
+   */
+  getCooldownDurationMs() {
+    return _ProviderManager.COOLDOWN_DURATION_MS;
+  }
+  /**
+   * Check if a provider is currently on cooldown
+   */
+  isOnCooldown(baseUrl) {
+    this.cleanupExpiredCooldowns();
+    return this.providersOnCoolDown.some(([url]) => url === baseUrl);
+  }
+  /**
+   * Get all providers currently on cooldown
+   */
+  getProvidersOnCooldown() {
+    this.cleanupExpiredCooldowns();
+    return [...this.providersOnCoolDown];
+  }
   /**
    * Reset the failed providers list
    */
   resetFailedProviders() {
     this.failedProviders.clear();
   }
+  /**
+   * Get the last failed timestamp for a provider
+   */
+  getLastFailed(baseUrl) {
+    return this.lastFailed.get(baseUrl);
+  }
+  /**
+   * Get all providers with their last failed timestamps
+   */
+  getAllLastFailed() {
+    return new Map(this.lastFailed);
+  }
   /**
    * Mark a provider as failed
+   * If a provider fails twice within 5 minutes, it's added to cooldown
    */
   markFailed(baseUrl) {
+    const now = Date.now();
+    const lastFailure = this.lastFailed.get(baseUrl);
+    this.lastFailed.set(baseUrl, now);
     this.failedProviders.add(baseUrl);
+    if (lastFailure !== void 0 && now - lastFailure < _ProviderManager.COOLDOWN_DURATION_MS) {
+      if (!this.isOnCooldown(baseUrl)) {
+        this.providersOnCoolDown.push([baseUrl, now]);
+        console.log(
+          `Provider ${baseUrl} added to cooldown after second failure within 5 minutes`
+        );
+      }
+    }
+  }
+  /**
+   * Remove a provider from cooldown (e.g., after successful request)
+   */
+  removeFromCooldown(baseUrl) {
+    this.providersOnCoolDown = this.providersOnCoolDown.filter(
+      ([url]) => url !== baseUrl
+    );
+  }
+  /**
+   * Clear all cooldown tracking
+   */
+  clearCooldowns() {
+    this.providersOnCoolDown = [];
+  }
+  /**
+   * Clear all failure tracking (lastFailed timestamps)
+   */
+  clearFailureHistory() {
+    this.lastFailed.clear();
   }
   /**
    * Check if a provider has failed
@@ -2338,6 +2445,12 @@ var ProviderManager = class {
   hasFailed(baseUrl) {
     return this.failedProviders.has(baseUrl);
   }
+  /**
+   * Get a copy of the failed providers set
+   */
+  getFailedProviders() {
+    return new Set(this.failedProviders);
+  }
   /**
    * Find the next best provider for a model
    * @param modelId The model ID to find a provider for
@@ -2353,7 +2466,7 @@ var ProviderManager = class {
       const allProviders = this.providerRegistry.getAllProvidersModels();
       const candidates = [];
       for (const [baseUrl, models] of Object.entries(allProviders)) {
-        if (baseUrl === currentBaseUrl || this.failedProviders.has(baseUrl) || disabledProviders.has(baseUrl)) {
+        if (baseUrl === currentBaseUrl || this.failedProviders.has(baseUrl) || disabledProviders.has(baseUrl) || this.isOnCooldown(baseUrl)) {
           continue;
         }
         if (!torMode && (isOnionUrl(baseUrl) || isInsecureHttpUrl(baseUrl))) {
@@ -2400,6 +2513,7 @@ var ProviderManager = class {
     const torMode = isTorContext();
     for (const [baseUrl, models] of Object.entries(allProviders)) {
       if (disabledProviders.has(baseUrl)) continue;
+      if (this.isOnCooldown(baseUrl)) continue;
       if (!torMode && (isOnionUrl(baseUrl) || isInsecureHttpUrl(baseUrl)))
         continue;
       const model = models.find((m) => m.id === modelId);
@@ -2423,6 +2537,7 @@ var ProviderManager = class {
     const results = [];
     for (const [baseUrl, models] of Object.entries(allModels)) {
       if (!includeDisabled && disabledProviders.has(baseUrl)) continue;
+      if (this.isOnCooldown(baseUrl)) continue;
       if (torMode && !baseUrl.includes(".onion")) continue;
       if (!torMode && (baseUrl.includes(".onion") || isInsecureHttpUrl(baseUrl)))
         continue;
@@ -2836,7 +2951,6 @@ var RoutstrClient = class {
         body: body === void 0 || method === "GET" ? void 0 : JSON.stringify(body)
       });
       if (this.mode === "xcashu") this._log("DEBUG", "response,", response);
-      this._log("DEBUG", "response,", response);
       response.baseUrl = baseUrl;
       response.token = token;
       if (!response.ok) {
@@ -2859,7 +2973,7 @@ var RoutstrClient = class {
       }
       return response;
     } catch (error) {
-      if (this._isNetworkError(error?.message || "")) {
+      if (isNetworkErrorMessage(error?.message || "")) {
         return await this._handleErrorResponse(
           params,
           token,
@@ -2994,7 +3108,13 @@ var RoutstrClient = class {
             "DEBUG",
             `[RoutstrClient] _handleErrorResponse: Insufficient balance, need=${required}, have=${available}`
           );
-          throw new InsufficientBalanceError(required, available, 0, "", message);
+          throw new InsufficientBalanceError(
+            required,
+            available,
+            0,
+            "",
+            message
+          );
         } else {
           this._log(
             "DEBUG",
@@ -3207,7 +3327,10 @@ var RoutstrClient = class {
         retryCount: 0
       });
     }
-    throw new FailoverError(baseUrl, Array.from(this.providerManager));
+    throw new FailoverError(
+      baseUrl,
+      Array.from(this.providerManager.getFailedProviders())
+    );
   }
   /**
    * Handle post-response balance update for all modes
@@ -3357,12 +3480,6 @@ var RoutstrClient = class {
     const distribution = this.storageAdapter.getCachedTokenDistribution();
     return distribution.reduce((total, item) => total + item.amount, 0);
   }
-  /**
-   * Check if error message indicates a network error
-   */
-  _isNetworkError(message) {
-    return message.includes("NetworkError when attempting to fetch resource") || message.includes("Failed to fetch") || message.includes("Load failed");
-  }
   /**
    * Handle errors and notify callbacks
    */