@routstr/sdk 0.2.5 → 0.2.6

package/dist/wallet/index.js

@@ -122,13 +122,8 @@ var CashuSpender = class {
       normalizedMintBalances[url] = balanceInSats;
       totalMintBalance += balanceInSats;
     }
-    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
     const providerBalances = {};
     let totalProviderBalance = 0;
-    for (const pending of pendingDistribution) {
-      providerBalances[pending.baseUrl] = (providerBalances[pending.baseUrl] || 0) + pending.amount;
-      totalProviderBalance += pending.amount;
-    }
     const apiKeys = this.storageAdapter.getAllApiKeys();
     for (const apiKey of apiKeys) {
       if (!providerBalances[apiKey.baseUrl]) {
@@ -349,27 +344,11 @@ var CashuSpender = class {
         };
       }
     }
-    if (token && baseUrl) {
-      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;
-        }
-      }
+    if (token) {
+      this._log(
+        "DEBUG",
+        `[CashuSpender] _spendInternal: Successfully spent ${spentAmount}, returning token with balance=${spentAmount}`
+      );
     }
     this._logTransaction("spend", {
       amount: spentAmount,
@@ -390,19 +369,19 @@ var CashuSpender = class {
     };
   }
   /**
-   * Try to reuse an existing token
+   * Try to reuse an existing API key
    */
   async _tryReuseToken(baseUrl, amount, mintUrl) {
-    const storedToken = this.storageAdapter.getToken(baseUrl);
-    if (!storedToken) return null;
-    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
-    const balanceForBaseUrl = pendingDistribution.find((b) => b.baseUrl === baseUrl)?.amount || 0;
-    this._log("DEBUG", "RESUINGDSR GSODGNSD", balanceForBaseUrl, amount);
+    const apiKeyEntry = this.storageAdapter.getApiKey(baseUrl);
+    if (!apiKeyEntry) return null;
+    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+    const balanceForBaseUrl = apiKeyDistribution.find((b) => b.baseUrl === baseUrl)?.amount || 0;
+    this._log("DEBUG", "Reusing API key", balanceForBaseUrl, amount);
     if (balanceForBaseUrl > amount) {
       const units = this.walletAdapter.getMintUnits();
       const unit = units[mintUrl] || "sat";
       return {
-        token: storedToken,
+        token: apiKeyEntry.key,
         status: "success",
         balance: balanceForBaseUrl,
         unit
@@ -413,7 +392,8 @@ var CashuSpender = class {
       const topUpResult = await this.balanceManager.topUp({
         mintUrl,
         baseUrl,
-        amount: topUpAmount
+        amount: topUpAmount,
+        token: apiKeyEntry.key
       });
       this._log("DEBUG", "TOPUP ", topUpResult);
       if (topUpResult.success && topUpResult.toppedUpAmount) {
@@ -427,7 +407,7 @@ var CashuSpender = class {
           status: "success"
         });
         return {
-          token: storedToken,
+          token: apiKeyEntry.key,
           status: "success",
           balance: newBalance,
           unit
@@ -435,84 +415,108 @@ var CashuSpender = class {
       }
       const providerBalance = await this._getProviderTokenBalance(
         baseUrl,
-        storedToken
+        apiKeyEntry.key
       );
       this._log("DEBUG", providerBalance);
       if (providerBalance <= 0) {
-        this.storageAdapter.removeToken(baseUrl);
+        this.storageAdapter.removeApiKey(baseUrl);
       }
     }
     return null;
   }
   /**
-   * Refund specific providers without retrying spend
+   * Refund all xcashu tokens from storage and increment tryCounts on failure.
+   * Reuses receiveToken from BalanceManager/CashuSpender for receiving refunds.
+   * @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
    */
-  async refundProviders(baseUrls, mintUrl, refundApiKeys = false, forceRefund) {
+  async refundXcashuTokens(mintUrl, excludeBaseUrls) {
     const results = [];
-    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
-    const toRefund = pendingDistribution.filter(
-      (p) => baseUrls.includes(p.baseUrl)
-    );
-    const refundResults = await Promise.allSettled(
-      toRefund.map(async (pending) => {
-        const token = this.storageAdapter.getToken(pending.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
-        );
-        if (tokenBalance.reserved > 0) {
-          return { baseUrl: pending.baseUrl, success: false };
-        }
-        const result = await this.balanceManager.refund({
-          mintUrl,
-          baseUrl: pending.baseUrl,
-          token
-        });
-        this._log("DEBUG", result);
-        if (result.success) {
-          this.storageAdapter.removeToken(pending.baseUrl);
-        }
-        return { baseUrl: pending.baseUrl, success: result.success };
-      })
-    );
-    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)
-      );
-      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,
-            forceRefund
-          });
-          if (refundResult.success) {
-            this.storageAdapter.updateApiKeyBalance(apiKeyEntry.baseUrl, 0);
+    const xcashuTokens = this.storageAdapter.getXcashuTokens();
+    const excludedUrls = new Set(excludeBaseUrls || []);
+    for (const [baseUrl, tokens] of Object.entries(xcashuTokens)) {
+      if (excludedUrls.has(baseUrl)) continue;
+      for (const xcashuToken of tokens) {
+        try {
+          const receiveResult = await this.receiveToken(xcashuToken.token);
+          if (receiveResult.success) {
+            this.storageAdapter.removeXcashuToken(baseUrl, xcashuToken.token);
+            results.push({
+              baseUrl,
+              token: xcashuToken.token,
+              success: true
+            });
+            this._log(
+              "DEBUG",
+              `[CashuSpender] refundXcashuTokens: Successfully refunded xcashu token for ${baseUrl}, amount=${receiveResult.amount}`
+            );
+          } else {
+            const currentTryCount = xcashuToken.tryCount ?? 0;
+            const newTryCount = currentTryCount + 1;
+            this.storageAdapter.updateXcashuTokenTryCount(xcashuToken.token, newTryCount);
+            results.push({
+              baseUrl,
+              token: xcashuToken.token,
+              success: false,
+              error: receiveResult.message ?? "Refund failed"
+            });
+            this._log(
+              "DEBUG",
+              `[CashuSpender] refundXcashuTokens: Failed to refund xcashu token for ${baseUrl}, incremented tryCount to ${newTryCount}`
+            );
           }
+        } catch (error) {
+          const currentTryCount = xcashuToken.tryCount ?? 0;
+          const newTryCount = currentTryCount + 1;
+          this.storageAdapter.updateXcashuTokenTryCount(xcashuToken.token, newTryCount);
+          const errorMessage = error instanceof Error ? error.message : String(error);
           results.push({
-            baseUrl: apiKeyEntry.baseUrl,
-            success: refundResult.success
+            baseUrl,
+            token: xcashuToken.token,
+            success: false,
+            error: errorMessage
           });
+          this._log(
+            "ERROR",
+            `[CashuSpender] refundXcashuTokens: Exception during refund for ${baseUrl}: ${errorMessage}, incremented tryCount to ${newTryCount}`
+          );
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Refund specific providers without retrying spend
+   */
+  async refundProviders(mintUrl, forceRefund) {
+    const results = [];
+    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
+    for (const apiKeyEntry of apiKeyDistribution) {
+      const apiKeyEntryFull = this.storageAdapter.getApiKey(
+        apiKeyEntry.baseUrl
+      );
+      if (apiKeyEntryFull && this.balanceManager) {
+        const refundResult = await this.balanceManager.refundApiKey({
+          mintUrl,
+          baseUrl: apiKeyEntry.baseUrl,
+          apiKey: apiKeyEntryFull.key,
+          forceRefund
+        });
+        if (refundResult.success) {
+          this.storageAdapter.removeApiKey(apiKeyEntry.baseUrl);
         } else {
-          results.push({
-            baseUrl: apiKeyEntry.baseUrl,
-            success: false
-          });
+          this.storageAdapter.updateApiKeyBalance(apiKeyEntry.baseUrl, apiKeyEntry.amount);
         }
+        results.push({
+          baseUrl: apiKeyEntry.baseUrl,
+          success: refundResult.success
+        });
+      } else {
+        results.push({
+          baseUrl: apiKeyEntry.baseUrl,
+          success: false
+        });
       }
     }
     return results;
@@ -597,13 +601,8 @@ var BalanceManager = class {
       normalizedMintBalances[url] = balanceInSats;
       totalMintBalance += balanceInSats;
     }
-    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
     const providerBalances = {};
     let totalProviderBalance = 0;
-    for (const pending of pendingDistribution) {
-      providerBalances[pending.baseUrl] = (providerBalances[pending.baseUrl] || 0) + pending.amount;
-      totalProviderBalance += pending.amount;
-    }
     const apiKeys = this.storageAdapter.getAllApiKeys();
     for (const apiKey of apiKeys) {
       if (!providerBalances[apiKey.baseUrl]) {
@@ -618,57 +617,6 @@ var BalanceManager = class {
       mintBalances: normalizedMintBalances
     };
   }
-  /**
-   * Unified refund - handles both NIP-60 and legacy wallet refunds
-   */
-  async refund(options) {
-    const { mintUrl, baseUrl, token: providedToken } = options;
-    const storedToken = providedToken || this.storageAdapter.getToken(baseUrl);
-    if (!storedToken) {
-      console.log("[BalanceManager] No token to refund, returning early");
-      return { success: true, message: "No API key to refund" };
-    }
-    let fetchResult;
-    try {
-      fetchResult = await this._fetchRefundToken(baseUrl, storedToken);
-      if (!fetchResult.success) {
-        return {
-          success: false,
-          message: fetchResult.error || "Refund failed",
-          requestId: fetchResult.requestId
-        };
-      }
-      if (!fetchResult.token) {
-        return {
-          success: false,
-          message: "No token received from refund",
-          requestId: fetchResult.requestId
-        };
-      }
-      if (fetchResult.error === "No balance to refund") {
-        console.log(
-          "[BalanceManager] No balance to refund, removing stored token"
-        );
-        this.storageAdapter.removeToken(baseUrl);
-        return { success: true, message: "No balance to refund" };
-      }
-      const receiveResult = await this.cashuSpender.receiveToken(
-        fetchResult.token
-      );
-      const totalAmountMsat = receiveResult.unit === "msat" ? receiveResult.amount : receiveResult.amount * 1e3;
-      if (!providedToken) {
-        this.storageAdapter.removeToken(baseUrl);
-      }
-      return {
-        success: receiveResult.success,
-        refundedAmount: totalAmountMsat,
-        requestId: fetchResult.requestId
-      };
-    } catch (error) {
-      console.error("[BalanceManager] Refund error", error);
-      return this._handleRefundError(error, mintUrl, fetchResult?.requestId);
-    }
-  }
   /**
    * Refund API key balance - convert remaining API key balance to cashu token
    * @param options - Refund options including forceRefund flag
@@ -804,8 +752,9 @@ var BalanceManager = class {
     if (!amount || amount <= 0) {
       return { success: false, message: "Invalid top up amount" };
     }
-    const storedToken = providedToken || this.storageAdapter.getToken(baseUrl);
-    if (!storedToken) {
+    const apiKeyEntry = providedToken ? null : this.storageAdapter.getApiKey(baseUrl);
+    const apiKey = providedToken || apiKeyEntry?.key;
+    if (!apiKey) {
       return { success: false, message: "No API key available for top up" };
     }
     let cashuToken = null;
@@ -825,7 +774,7 @@ var BalanceManager = class {
       cashuToken = tokenResult.token;
       const topUpResult = await this._postTopUp(
         baseUrl,
-        storedToken,
+        apiKey,
         cashuToken
       );
       requestId = topUpResult.requestId;
@@ -1040,38 +989,11 @@ var BalanceManager = class {
     return candidates;
   }
   async _refundOtherProvidersForTopUp(baseUrl, mintUrl, retryCount) {
-    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
     const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
     const forceRefund = retryCount >= 2;
-    const toRefund = pendingDistribution.filter(
-      (pending) => pending.baseUrl !== baseUrl
-    );
     const apiKeysToRefund = apiKeyDistribution.filter(
       (apiKey) => apiKey.baseUrl !== baseUrl && apiKey.amount > 0
     );
-    const tokenRefundResults = 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 tokenRefundResults) {
-      if (result.status === "fulfilled" && result.value.success) {
-        this.storageAdapter.removeToken(result.value.baseUrl);
-      }
-    }
     const apiKeyRefundResults = await Promise.allSettled(
       apiKeysToRefund.map(async (apiKeyEntry) => {
         const fullApiKeyEntry = this.storageAdapter.getApiKey(
@@ -1095,77 +1017,6 @@ var BalanceManager = class {
       }
     }
   }
-  /**
-   * 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,
-        requestId
-      };
-    } catch (error) {
-      clearTimeout(timeoutId);
-      console.error("[BalanceManager._fetchRefundToken] 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 refund request"
-      };
-    }
-  }
   /**
    * Post topup request to provider API
    */