@routstr/sdk 0.1.7 → 0.2.0

package/dist/client/index.js

@@ -2,9 +2,9 @@
 
 // core/errors.ts
 var InsufficientBalanceError = class extends Error {
-  constructor(required, available, maxMintBalance = 0, maxMintUrl = "") {
+  constructor(required, available, maxMintBalance = 0, maxMintUrl = "", customMessage) {
     super(
-      `Insufficient balance: need ${required} sats, have ${available} sats available. ` + (maxMintBalance > 0 ? `Largest mint balance: ${maxMintBalance} sats from ${maxMintUrl}` : "")
+      customMessage ?? `Insufficient balance: need ${required} sats, have ${available} sats available. ` + (maxMintBalance > 0 ? `Largest mint balance: ${maxMintBalance} sats from ${maxMintUrl}` : "")
     );
     this.required = required;
     this.available = available;
@@ -129,6 +129,9 @@ var CashuSpender = class {
     return result;
   }
   async _getBalanceState() {
+    if (this.balanceManager) {
+      return this.balanceManager.getBalanceState();
+    }
     const mintBalances = await this.walletAdapter.getBalances();
     const units = this.walletAdapter.getMintUnits();
     let totalMintBalance = 0;
@@ -144,15 +147,16 @@ var CashuSpender = class {
     const providerBalances = {};
     let totalProviderBalance = 0;
     for (const pending of pendingDistribution) {
-      providerBalances[pending.baseUrl] = pending.amount;
+      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]) {
-        providerBalances[apiKey.baseUrl] = apiKey.balance;
-        totalProviderBalance += apiKey.balance;
+        providerBalances[apiKey.baseUrl] = 0;
       }
+      providerBalances[apiKey.baseUrl] += apiKey.balance;
+      totalProviderBalance += apiKey.balance;
     }
     return {
       totalBalance: totalMintBalance + totalProviderBalance,
@@ -301,25 +305,12 @@ var CashuSpender = class {
         `[CashuSpender] _spendInternal: Could not reuse token, will create new token`
       );
     }
-    const balances = await this.walletAdapter.getBalances();
-    const units = this.walletAdapter.getMintUnits();
-    let totalBalance = 0;
-    for (const url in balances) {
-      const balance = balances[url];
-      const unit = units[url];
-      const balanceInSats = getBalanceInSats(balance, unit);
-      totalBalance += balanceInSats;
-    }
-    const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
-    const totalPending = pendingDistribution.reduce(
-      (sum, item) => sum + item.amount,
-      0
-    );
+    const balanceState = await this._getBalanceState();
+    const totalAvailableBalance = balanceState.totalBalance;
     this._log(
       "DEBUG",
-      `[CashuSpender] _spendInternal: totalBalance=${totalBalance}, totalPending=${totalPending}, adjustedAmount=${adjustedAmount}`
+      `[CashuSpender] _spendInternal: totalAvailableBalance=${totalAvailableBalance}, adjustedAmount=${adjustedAmount}`
     );
-    const totalAvailableBalance = totalBalance + totalPending;
     if (totalAvailableBalance < adjustedAmount) {
       this._log(
         "ERROR",
@@ -327,8 +318,7 @@ var CashuSpender = class {
       );
       return this._createInsufficientBalanceError(
         adjustedAmount,
-        balances,
-        units,
+        balanceState.mintBalances,
         totalAvailableBalance
       );
     }
@@ -348,8 +338,7 @@ var CashuSpender = class {
         if ((tokenResult.error || "").includes("Insufficient balance")) {
           return this._createInsufficientBalanceError(
             adjustedAmount,
-            balances,
-            units,
+            balanceState.mintBalances,
             totalAvailableBalance
           );
         }
@@ -394,6 +383,7 @@ var CashuSpender = class {
       "DEBUG",
       `[CashuSpender] _spendInternal: Successfully spent ${spentAmount}, returning token with balance=${spentAmount}`
     );
+    const units = this.walletAdapter.getMintUnits();
     return {
       token,
       status: "success",
@@ -531,13 +521,11 @@ var CashuSpender = class {
   /**
    * Create an insufficient balance error result
    */
-  _createInsufficientBalanceError(required, balances, units, availableBalance) {
+  _createInsufficientBalanceError(required, normalizedBalances, availableBalance) {
     let maxBalance = 0;
     let maxMintUrl = "";
-    for (const mintUrl in balances) {
-      const balance = balances[mintUrl];
-      const unit = units[mintUrl];
-      const balanceInSats = getBalanceInSats(balance, unit);
+    for (const mintUrl in normalizedBalances) {
+      const balanceInSats = normalizedBalances[mintUrl];
       if (balanceInSats > maxBalance) {
         maxBalance = balanceInSats;
         maxMintUrl = mintUrl;
@@ -598,6 +586,39 @@ var BalanceManager = class {
     }
   }
   cashuSpender;
+  async getBalanceState() {
+    const mintBalances = await this.walletAdapter.getBalances();
+    const units = this.walletAdapter.getMintUnits();
+    let totalMintBalance = 0;
+    const normalizedMintBalances = {};
+    for (const url in mintBalances) {
+      const balance = mintBalances[url];
+      const unit = units[url];
+      const balanceInSats = getBalanceInSats(balance, unit);
+      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]) {
+        providerBalances[apiKey.baseUrl] = 0;
+      }
+      providerBalances[apiKey.baseUrl] += apiKey.balance;
+      totalProviderBalance += apiKey.balance;
+    }
+    return {
+      totalBalance: totalMintBalance + totalProviderBalance,
+      providerBalances,
+      mintBalances: normalizedMintBalances
+    };
+  }
   /**
    * Unified refund - handles both NIP-60 and legacy wallet refunds
    */
@@ -808,6 +829,10 @@ var BalanceManager = class {
         requestId
       };
     } catch (error) {
+      console.log(
+        "DEBUG",
+        `[TopuPU] topup: Topup result for ${baseUrl}: error=${error}`
+      );
       if (cashuToken) {
         await this._recoverFailedTopUp(cashuToken);
       }
@@ -827,23 +852,42 @@ var BalanceManager = class {
     if (!adjustedAmount || isNaN(adjustedAmount)) {
       return { success: false, error: "Invalid top up amount" };
     }
+    const balanceState = await this.getBalanceState();
     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) {
+    const totalMintBalance = Object.values(balanceState.mintBalances).reduce(
+      (sum, value) => sum + value,
+      0
+    );
+    const targetProviderBalance = balanceState.providerBalances[baseUrl] || 0;
+    const refundableProviderBalance = Object.entries(
+      balanceState.providerBalances
+    ).filter(([providerBaseUrl]) => providerBaseUrl !== baseUrl).reduce((sum, [, value]) => sum + value, 0);
+    if (totalMintBalance + targetProviderBalance < adjustedAmount && totalMintBalance + targetProviderBalance + refundableProviderBalance >= adjustedAmount && retryCount < 1) {
       await this._refundOtherProvidersForTopUp(baseUrl, mintUrl);
       return this.createProviderToken({
         ...options,
         retryCount: retryCount + 1
       });
     }
+    if (totalMintBalance + targetProviderBalance < adjustedAmount) {
+      const error = new InsufficientBalanceError(
+        adjustedAmount,
+        totalMintBalance + targetProviderBalance,
+        totalMintBalance,
+        Object.entries(balanceState.mintBalances).reduce(
+          (max, [url, balance]) => balance > max.balance ? { url, balance } : max,
+          { url: "", balance: 0 }
+        ).url
+      );
+      return { success: false, error: error.message };
+    }
+    if (targetProviderBalance >= adjustedAmount) {
+      return {
+        success: true,
+        amountSpent: 0
+      };
+    }
     const providerMints = baseUrl && this.providerRegistry ? this.providerRegistry.getProviderMints(baseUrl) : [];
     let requiredAmount = adjustedAmount;
     const supportedMintsOnly = providerMints.length > 0;
@@ -959,10 +1003,14 @@ var BalanceManager = class {
   }
   async _refundOtherProvidersForTopUp(baseUrl, mintUrl) {
     const pendingDistribution = this.storageAdapter.getCachedTokenDistribution();
+    const apiKeyDistribution = this.storageAdapter.getApiKeyDistribution();
     const toRefund = pendingDistribution.filter(
       (pending) => pending.baseUrl !== baseUrl
     );
-    const refundResults = await Promise.allSettled(
+    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) {
@@ -980,11 +1028,32 @@ var BalanceManager = class {
         return { baseUrl: pending.baseUrl, success: result.success };
       })
     );
-    for (const result of refundResults) {
+    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(
+          apiKeyEntry.baseUrl
+        );
+        if (!fullApiKeyEntry) {
+          return { baseUrl: apiKeyEntry.baseUrl, success: false };
+        }
+        const result = await this.refundApiKey({
+          mintUrl,
+          baseUrl: apiKeyEntry.baseUrl,
+          apiKey: fullApiKeyEntry.key
+        });
+        return { baseUrl: apiKeyEntry.baseUrl, success: result.success };
+      })
+    );
+    for (const result of apiKeyRefundResults) {
+      if (result.status === "fulfilled" && result.value.success) {
+        this.storageAdapter.updateApiKeyBalance(result.value.baseUrl, 0);
+      }
+    }
   }
   /**
    * Fetch refund token from provider API
@@ -2179,10 +2248,34 @@ var RoutstrClient = class {
       }
     }
     if (status === 402 && !tryNextProvider && (this.mode === "apikeys" || this.mode === "lazyrefund")) {
+      this.storageAdapter.getApiKey(baseUrl);
+      let topupAmount = params.requiredSats;
+      try {
+        let currentBalance = 0;
+        if (this.mode === "apikeys") {
+          const currentBalanceInfo = await this.balanceManager.getTokenBalance(
+            params.token,
+            baseUrl
+          );
+          currentBalance = currentBalanceInfo.unit === "msat" ? currentBalanceInfo.amount / 1e3 : currentBalanceInfo.amount;
+        } else if (this.mode === "lazyrefund") {
+          const distribution = this.storageAdapter.getCachedTokenDistribution();
+          const tokenEntry = distribution.find((t) => t.baseUrl === baseUrl);
+          currentBalance = tokenEntry?.amount ?? 0;
+        }
+        const shortfall = Math.max(0, params.requiredSats - currentBalance);
+        topupAmount = shortfall > 0 ? shortfall : params.requiredSats;
+      } catch (e) {
+        this._log(
+          "WARN",
+          "Could not get current token balance for topup calculation:",
+          e
+        );
+      }
       const topupResult = await this.balanceManager.topUp({
         mintUrl,
         baseUrl,
-        amount: params.requiredSats * TOPUP_MARGIN,
+        amount: topupAmount * TOPUP_MARGIN,
         token: params.token
       });
       this._log(
@@ -2200,7 +2293,7 @@ var RoutstrClient = class {
             "DEBUG",
             `[RoutstrClient] _handleErrorResponse: Insufficient balance, need=${required}, have=${available}`
           );
-          throw new InsufficientBalanceError(required, available);
+          throw new InsufficientBalanceError(required, available, 0, "", message);
         } else {
           this._log(
             "DEBUG",
@@ -2263,7 +2356,10 @@ var RoutstrClient = class {
             retryToken = latestBalanceInfo.apiKey;
           }
           if (latestTokenBalance >= 0) {
-            this.storageAdapter.updateApiKeyBalance(baseUrl, latestTokenBalance);
+            this.storageAdapter.updateApiKeyBalance(
+              baseUrl,
+              latestTokenBalance
+            );
           }
         }
       } catch (error) {