@agether/sdk 2.4.0 → 2.6.0

package/dist/index.js

@@ -532,11 +532,6 @@ var AgetherClient = class _AgetherClient {
 // src/clients/MorphoClient.ts
 var import_ethers2 = require("ethers");
 var import_axios = __toESM(require("axios"));
-var BASE_COLLATERALS = {
-  WETH: { address: "0x4200000000000000000000000000000000000006", symbol: "WETH", decimals: 18 },
-  wstETH: { address: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452", symbol: "wstETH", decimals: 18 },
-  cbETH: { address: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22", symbol: "cbETH", decimals: 18 }
-};
 var MORPHO_API_URL = "https://api.morpho.org/graphql";
 var MODE_SINGLE = "0x0000000000000000000000000000000000000000000000000000000000000000";
 var MODE_BATCH = "0x0100000000000000000000000000000000000000000000000000000000000000";
@@ -545,6 +540,8 @@ var erc20Iface = new import_ethers2.ethers.Interface(ERC20_ABI);
 var MorphoClient = class {
   constructor(config) {
     this._marketCache = /* @__PURE__ */ new Map();
+    /** Dynamic token registry: symbol (uppercase) → { address, symbol, decimals } */
+    this._tokenCache = /* @__PURE__ */ new Map();
     this._discoveredAt = 0;
     const chainId = config.chainId ?? 8453 /* Base */;
     const defaultCfg = getDefaultConfig(chainId);
@@ -731,15 +728,16 @@ var MorphoClient = class {
     const usdc = new import_ethers2.Contract(this.config.contracts.usdc, ERC20_ABI, this.provider);
     const ethBal = await this.provider.getBalance(eoaAddr);
     const usdcBal = await usdc.balanceOf(eoaAddr);
+    const discoveredTokens = await this._getDiscoveredTokens();
     const eoaCollateral = {};
-    for (const [symbol, info] of Object.entries(BASE_COLLATERALS)) {
+    for (const info of discoveredTokens) {
       try {
         const token = new import_ethers2.Contract(info.address, ERC20_ABI, this.provider);
         const bal = await token.balanceOf(eoaAddr);
-        eoaCollateral[symbol] = import_ethers2.ethers.formatUnits(bal, info.decimals);
+        eoaCollateral[info.symbol] = import_ethers2.ethers.formatUnits(bal, info.decimals);
       } catch (e) {
-        console.warn(`[agether] EOA collateral fetch failed for ${symbol}:`, e instanceof Error ? e.message : e);
-        eoaCollateral[symbol] = "0";
+        console.warn(`[agether] EOA collateral fetch failed for ${info.symbol}:`, e instanceof Error ? e.message : e);
+        eoaCollateral[info.symbol] = "0";
       }
     }
     const result = {
@@ -754,14 +752,14 @@ var MorphoClient = class {
       const acctEth = await this.provider.getBalance(acctAddr);
       const acctUsdc = await usdc.balanceOf(acctAddr);
       const acctCollateral = {};
-      for (const [symbol, info] of Object.entries(BASE_COLLATERALS)) {
+      for (const info of discoveredTokens) {
         try {
           const token = new import_ethers2.Contract(info.address, ERC20_ABI, this.provider);
           const bal = await token.balanceOf(acctAddr);
-          acctCollateral[symbol] = import_ethers2.ethers.formatUnits(bal, info.decimals);
+          acctCollateral[info.symbol] = import_ethers2.ethers.formatUnits(bal, info.decimals);
         } catch (e) {
-          console.warn(`[agether] AgentAccount collateral fetch failed for ${symbol}:`, e instanceof Error ? e.message : e);
-          acctCollateral[symbol] = "0";
+          console.warn(`[agether] AgentAccount collateral fetch failed for ${info.symbol}:`, e instanceof Error ? e.message : e);
+          acctCollateral[info.symbol] = "0";
         }
       }
       result.agentAccount = {
@@ -788,6 +786,50 @@ var MorphoClient = class {
     this._refreshSigner();
     return { tx: receipt.hash, amount: usdcAmount, agentAccount: acctAddr };
   }
+  /**
+   * Withdraw (transfer) a token from AgentAccount to EOA.
+   * Executes an ERC-20 transfer via Safe UserOp.
+   *
+   * @param tokenSymbol - Token to withdraw (e.g. 'USDC', 'WETH', 'wstETH')
+   * @param amount - Amount to withdraw (human-readable, e.g. '100' for 100 USDC, or 'all')
+   */
+  async withdrawToken(tokenSymbol, amount) {
+    const acctAddr = await this.getAccountAddress();
+    const eoaAddr = await this.getSignerAddress();
+    const tokenInfo = await this._resolveToken(tokenSymbol);
+    const tokenContract = new import_ethers2.Contract(tokenInfo.address, ERC20_ABI, this.provider);
+    let weiAmount;
+    if (amount === "all") {
+      weiAmount = await tokenContract.balanceOf(acctAddr);
+      if (weiAmount === 0n) throw new AgetherError(`No ${tokenSymbol} in AgentAccount`, "INSUFFICIENT_BALANCE");
+    } else {
+      weiAmount = import_ethers2.ethers.parseUnits(amount, tokenInfo.decimals);
+    }
+    const data = erc20Iface.encodeFunctionData("transfer", [eoaAddr, weiAmount]);
+    const receipt = await this.exec(tokenInfo.address, data);
+    const actualAmount = amount === "all" ? import_ethers2.ethers.formatUnits(weiAmount, tokenInfo.decimals) : amount;
+    return { tx: receipt.hash, token: tokenSymbol, amount: actualAmount, destination: eoaAddr };
+  }
+  /**
+   * Withdraw ETH from AgentAccount to EOA.
+   * Executes a native ETH transfer via Safe UserOp.
+   *
+   * @param amount - ETH amount (e.g. '0.01' or 'all')
+   */
+  async withdrawEth(amount) {
+    const acctAddr = await this.getAccountAddress();
+    const eoaAddr = await this.getSignerAddress();
+    let weiAmount;
+    if (amount === "all") {
+      weiAmount = await this.provider.getBalance(acctAddr);
+      if (weiAmount === 0n) throw new AgetherError("No ETH in AgentAccount", "INSUFFICIENT_BALANCE");
+    } else {
+      weiAmount = import_ethers2.ethers.parseEther(amount);
+    }
+    const receipt = await this.exec(eoaAddr, "0x", weiAmount);
+    const actualAmount = amount === "all" ? import_ethers2.ethers.formatEther(weiAmount) : amount;
+    return { tx: receipt.hash, token: "ETH", amount: actualAmount, destination: eoaAddr };
+  }
   // ════════════════════════════════════════════════════════
   //  Market Discovery (Morpho GraphQL API)
   // ════════════════════════════════════════════════════════
@@ -847,6 +889,28 @@ var MorphoClient = class {
             irm: mi.irm,
             lltv: mi.lltv
           });
+          this._tokenCache.set(mi.collateralAsset.symbol.toUpperCase(), {
+            address: mi.collateralAsset.address,
+            symbol: mi.collateralAsset.symbol,
+            decimals: mi.collateralAsset.decimals
+          });
+          this._tokenCache.set(mi.collateralAsset.address.toLowerCase(), {
+            address: mi.collateralAsset.address,
+            symbol: mi.collateralAsset.symbol,
+            decimals: mi.collateralAsset.decimals
+          });
+        }
+        if (mi.loanAsset.address !== import_ethers2.ethers.ZeroAddress) {
+          this._tokenCache.set(mi.loanAsset.symbol.toUpperCase(), {
+            address: mi.loanAsset.address,
+            symbol: mi.loanAsset.symbol,
+            decimals: mi.loanAsset.decimals
+          });
+          this._tokenCache.set(mi.loanAsset.address.toLowerCase(), {
+            address: mi.loanAsset.address,
+            symbol: mi.loanAsset.symbol,
+            decimals: mi.loanAsset.decimals
+          });
         }
       }
       return this._discoveredMarkets;
@@ -860,8 +924,17 @@ var MorphoClient = class {
    * Tries cache → API → onchain idToMarketParams.
    */
   async findMarketForCollateral(collateralSymbolOrAddress) {
-    const colInfo = BASE_COLLATERALS[collateralSymbolOrAddress];
-    const colAddr = (colInfo?.address ?? collateralSymbolOrAddress).toLowerCase();
+    let colAddr;
+    if (collateralSymbolOrAddress.startsWith("0x")) {
+      colAddr = collateralSymbolOrAddress.toLowerCase();
+    } else {
+      try {
+        const resolved = await this._resolveToken(collateralSymbolOrAddress);
+        colAddr = resolved.address.toLowerCase();
+      } catch {
+        colAddr = collateralSymbolOrAddress.toLowerCase();
+      }
+    }
     const cached = this._marketCache.get(colAddr);
     if (cached) return cached;
     await this.getMarkets();
@@ -1020,8 +1093,17 @@ var MorphoClient = class {
     const usdcAddr = this.config.contracts.usdc.toLowerCase();
     let collateralFilter = "";
     if (collateralSymbolOrAddress) {
-      const colInfo = BASE_COLLATERALS[collateralSymbolOrAddress];
-      const colAddr = (colInfo?.address ?? collateralSymbolOrAddress).toLowerCase();
+      let colAddr;
+      if (collateralSymbolOrAddress.startsWith("0x")) {
+        colAddr = collateralSymbolOrAddress.toLowerCase();
+      } else {
+        try {
+          const resolved = await this._resolveToken(collateralSymbolOrAddress);
+          colAddr = resolved.address.toLowerCase();
+        } catch {
+          colAddr = collateralSymbolOrAddress.toLowerCase();
+        }
+      }
       collateralFilter = `, collateralAssetAddress_in: ["${colAddr}"]`;
     }
     const query = `{
@@ -1080,8 +1162,7 @@ var MorphoClient = class {
    * @returns Estimated yield in USD for the period
    */
   async getYieldEstimate(collateralSymbol, amount, periodDays = 1, ethPriceUsd) {
-    const colInfo = BASE_COLLATERALS[collateralSymbol];
-    if (!colInfo) throw new AgetherError(`Unknown collateral: ${collateralSymbol}`, "UNKNOWN_COLLATERAL");
+    const colInfo = await this._resolveToken(collateralSymbol);
     const rates = await this.getMarketRates(collateralSymbol);
     if (rates.length === 0) {
       throw new AgetherError(`No market found for ${collateralSymbol}`, "MARKET_NOT_FOUND");
@@ -1383,8 +1464,7 @@ var MorphoClient = class {
    */
   async supplyCollateral(tokenSymbol, amount, marketParams) {
     const acctAddr = await this.getAccountAddress();
-    const colInfo = BASE_COLLATERALS[tokenSymbol];
-    if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
+    const colInfo = await this._resolveToken(tokenSymbol);
     const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
     const weiAmount = import_ethers2.ethers.parseUnits(amount, colInfo.decimals);
     const morphoAddr = this.config.contracts.morphoBlue;
@@ -1505,8 +1585,7 @@ var MorphoClient = class {
    */
   async depositAndBorrow(tokenSymbol, collateralAmount, borrowUsdcAmount, marketParams) {
     const acctAddr = await this.getAccountAddress();
-    const colInfo = BASE_COLLATERALS[tokenSymbol];
-    if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
+    const colInfo = await this._resolveToken(tokenSymbol);
     const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
     const colWei = import_ethers2.ethers.parseUnits(collateralAmount, colInfo.decimals);
     const borrowWei = import_ethers2.ethers.parseUnits(borrowUsdcAmount, 6);
@@ -1674,8 +1753,7 @@ var MorphoClient = class {
    */
   async withdrawCollateral(tokenSymbol, amount, marketParams, receiver) {
     const acctAddr = await this.getAccountAddress();
-    const colInfo = BASE_COLLATERALS[tokenSymbol];
-    if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
+    const colInfo = await this._resolveToken(tokenSymbol);
     const params = marketParams ?? await this.findMarketForCollateral(tokenSymbol);
     const morphoAddr = this.config.contracts.morphoBlue;
     const usdcAddr = this.config.contracts.usdc;
@@ -1772,8 +1850,7 @@ var MorphoClient = class {
    * (The agent must then supplyCollateral themselves via their own account.)
    */
   async sponsor(target, tokenSymbol, amount) {
-    const colInfo = BASE_COLLATERALS[tokenSymbol];
-    if (!colInfo) throw new AgetherError(`Unknown collateral: ${tokenSymbol}`, "UNKNOWN_COLLATERAL");
+    const colInfo = await this._resolveToken(tokenSymbol);
     let targetAddr;
     if (target.address) {
       targetAddr = target.address;
@@ -2029,6 +2106,43 @@ var MorphoClient = class {
     }
     throw new AgetherError("No active supply position found", "NO_SUPPLY");
   }
+  /**
+   * Resolve a token symbol or address to { address, symbol, decimals }.
+   *
+   * Uses the dynamic `_tokenCache` populated by `getMarkets()` from the
+   * Morpho GraphQL API — no hardcoded token list needed.
+   *
+   * @param symbolOrAddress - e.g. 'WETH', 'wstETH', or '0x4200...'
+   */
+  async _resolveToken(symbolOrAddress) {
+    const key = symbolOrAddress.startsWith("0x") ? symbolOrAddress.toLowerCase() : symbolOrAddress.toUpperCase();
+    const cached = this._tokenCache.get(key);
+    if (cached) return cached;
+    await this.getMarkets();
+    const fromApi = this._tokenCache.get(key);
+    if (fromApi) return fromApi;
+    throw new AgetherError(
+      `Unknown token: ${symbolOrAddress}. No Morpho market found with this collateral.`,
+      "UNKNOWN_COLLATERAL"
+    );
+  }
+  /**
+   * Get all discovered collateral tokens (for balance iteration, etc.).
+   * Returns unique tokens from the Morpho API market discovery.
+   */
+  async _getDiscoveredTokens() {
+    await this.getMarkets();
+    const seen = /* @__PURE__ */ new Set();
+    const tokens = [];
+    for (const [key, info] of this._tokenCache) {
+      if (key.startsWith("0x")) continue;
+      if (seen.has(info.address.toLowerCase())) continue;
+      seen.add(info.address.toLowerCase());
+      if (info.symbol === "USDC" || info.symbol === "USDbC") continue;
+      tokens.push(info);
+    }
+    return tokens;
+  }
   /**
    * Compute net deposited amounts per market using Morpho GraphQL API.
    *
@@ -2170,7 +2284,9 @@ var X402Client = class {
     this.paidFetch = (0, import_fetch.wrapFetchWithPayment)(fetch, client);
     const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
     const dailyLimit = config.dailySpendLimitUsdc ? BigInt(Math.round(parseFloat(config.dailySpendLimitUsdc) * 1e6)) : 0n;
-    this._spendingTracker = { date: today, totalBorrowed: 0n, dailyLimit };
+    const restored = config.initialSpendingState;
+    const restoredBorrowed = restored && restored.date === today ? BigInt(restored.totalBorrowed) : 0n;
+    this._spendingTracker = { date: today, totalBorrowed: restoredBorrowed, dailyLimit };
   }
   async get(url, opts) {
     return this.request(url, { ...opts, method: "GET" });
@@ -2199,66 +2315,122 @@ var X402Client = class {
     return (Number(remaining > 0n ? remaining : 0n) / 1e6).toFixed(2);
   }
   /**
-   * Pay with auto-draw: Make an x402 request with automatic Morpho borrowing.
+   * Pay with auto-funding: Make an x402 request with automatic USDC sourcing.
    *
-   * Flow:
-   * 1. Check USDC balance on AgentAccount
-   * 2. Probe the URL to discover payment amount (if 402)
-   * 3. If insufficient USDC, calculate deficit
-   * 4. Check spending limit
-   * 5. Borrow from Morpho via MorphoClient
-   * 6. Proceed with x402 payment
+   * Uses a **plan-then-execute** approach: all reads happen first, and if the
+   * full deficit can't be covered the method fails with NO side-effects
+   * (no yield withdrawn, no USDC borrowed).
+   *
+   * Waterfall (when both autoYield + autoDraw enabled):
+   *   1. Check USDC balance on AgentAccount
+   *   2. Probe the URL to discover payment amount (if 402)
+   *   3. If insufficient USDC — PLANNING PHASE (read-only):
+   *      a. Calculate total available yield across supply positions
+   *      b. Calculate max borrowable from Morpho markets
+   *      c. Verify yield + borrow can cover full deficit — if not, fail immediately
+   *   4. EXECUTION PHASE (only if plan is feasible):
+   *      a. Withdraw needed yield from supply positions
+   *      b. Borrow remaining deficit from Morpho
+   *   5. Proceed with x402 payment
    */
   async payWithAutoDraw(url, opts) {
     const { morphoClient, ...fetchOpts } = opts || {};
-    if (!this.config.autoDraw || !morphoClient) {
+    if (!this.config.autoDraw && !this.config.autoYield || !morphoClient) {
       return this.request(url, fetchOpts);
     }
     try {
       const usdcBalance = await morphoClient.getUsdcBalance();
-      console.log(`   [auto-draw] AgentAccount USDC balance: ${(Number(usdcBalance) / 1e6).toFixed(2)}`);
+      console.log(`   [auto-fund] AgentAccount USDC balance: ${(Number(usdcBalance) / 1e6).toFixed(2)}`);
       const paymentAmount = await this._probePaymentAmount(url, fetchOpts);
       if (paymentAmount !== null) {
-        console.log(`   [auto-draw] Payment required: ${(Number(paymentAmount) / 1e6).toFixed(6)} USDC`);
+        console.log(`   [auto-fund] Payment required: ${(Number(paymentAmount) / 1e6).toFixed(6)} USDC`);
         const bufferStr = this.config.autoDrawBuffer || "0.5";
         const buffer = BigInt(Math.round(parseFloat(bufferStr) * 1e6));
         const needed = paymentAmount + buffer;
         if (usdcBalance < needed) {
-          const deficit = needed - usdcBalance;
-          console.log(`   [auto-draw] Insufficient balance. Need to borrow ${(Number(deficit) / 1e6).toFixed(2)} USDC`);
-          const limitCheck = await this._checkSpendingLimit(deficit, morphoClient);
-          if (!limitCheck.allowed) {
-            return {
-              success: false,
-              error: `Auto-draw blocked: ${limitCheck.reason}`
-            };
+          const totalDeficit = needed - usdcBalance;
+          console.log(`   [auto-fund] Insufficient balance. Deficit: ${(Number(totalDeficit) / 1e6).toFixed(2)} USDC`);
+          const yieldPlan = [];
+          let totalYieldAvailable = 0n;
+          if (this.config.autoYield) {
+            try {
+              const positions = await morphoClient.getSupplyPositions();
+              const withYield = positions.filter((p) => parseFloat(p.earnedYield) > 1e-6).sort((a, b) => parseFloat(b.earnedYield) - parseFloat(a.earnedYield));
+              for (const pos of withYield) {
+                const yieldRaw = BigInt(Math.floor(parseFloat(pos.earnedYield) * 1e6));
+                if (yieldRaw > 0n) {
+                  yieldPlan.push({ collateralToken: pos.collateralToken, amount: yieldRaw });
+                  totalYieldAvailable += yieldRaw;
+                }
+              }
+              console.log(`   [auto-fund] Plan: ${(Number(totalYieldAvailable) / 1e6).toFixed(6)} USDC available from yield`);
+            } catch (e) {
+              console.warn(`   [auto-fund] Plan: yield check failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
           }
-          const maxBorrowable = await morphoClient.getMaxBorrowable();
-          if (maxBorrowable.total < deficit) {
+          const yieldToUse = totalYieldAvailable < totalDeficit ? totalYieldAvailable : totalDeficit;
+          const deficitAfterYield = totalDeficit - yieldToUse;
+          let canBorrow = 0n;
+          if (this.config.autoDraw && deficitAfterYield > 0n) {
+            const limitCheck = await this._checkSpendingLimit(deficitAfterYield, morphoClient);
+            if (!limitCheck.allowed) {
+              return { success: false, error: `Auto-fund blocked: ${limitCheck.reason}` };
+            }
+            const maxBorrowable = await morphoClient.getMaxBorrowable();
+            canBorrow = maxBorrowable.total;
+            console.log(`   [auto-fund] Plan: ${(Number(canBorrow) / 1e6).toFixed(2)} USDC borrowable from Morpho`);
+          }
+          const totalAvailable = yieldToUse + canBorrow;
+          if (totalAvailable < totalDeficit) {
+            const parts = [];
+            if (totalYieldAvailable > 0n) parts.push(`yield: $${(Number(totalYieldAvailable) / 1e6).toFixed(2)}`);
+            if (canBorrow > 0n) parts.push(`borrowable: $${(Number(canBorrow) / 1e6).toFixed(2)}`);
+            if (!this.config.autoYield) parts.push("autoYield: off");
+            if (!this.config.autoDraw) parts.push("autoDraw: off");
             return {
               success: false,
-              error: `Auto-draw failed: insufficient collateral. Need ${(Number(deficit) / 1e6).toFixed(2)} USDC but can only borrow ${(Number(maxBorrowable.total) / 1e6).toFixed(2)} USDC more.`
+              error: `Cannot cover deficit of $${(Number(totalDeficit) / 1e6).toFixed(2)} USDC. Available: ${parts.join(", ")}. Balance: $${(Number(usdcBalance) / 1e6).toFixed(2)}, needed: $${(Number(needed) / 1e6).toFixed(2)}.`
             };
           }
-          const borrowAmount = (Number(deficit) / 1e6).toFixed(6);
-          console.log(`   [auto-draw] Borrowing ${borrowAmount} USDC from Morpho...`);
-          const borrowResult = await morphoClient.borrow(borrowAmount);
-          console.log(`   [auto-draw] Borrow tx: ${borrowResult.tx}`);
-          this._trackSpending(deficit);
-          const result = await this.request(url, fetchOpts);
-          return {
-            ...result,
-            autoDrawInfo: {
-              borrowed: borrowAmount,
-              borrowTx: borrowResult.tx,
-              reason: `USDC balance insufficient (had ${(Number(usdcBalance) / 1e6).toFixed(2)}, needed ${(Number(needed) / 1e6).toFixed(2)})`
-            }
+          const drawInfo = {
+            reason: `USDC balance insufficient (had ${(Number(usdcBalance) / 1e6).toFixed(2)}, needed ${(Number(needed) / 1e6).toFixed(2)})`
           };
+          if (yieldToUse > 0n) {
+            let remaining = yieldToUse;
+            let totalWithdrawn = 0n;
+            let lastTx = "";
+            for (const plan of yieldPlan) {
+              if (remaining <= 0n) break;
+              const toWithdraw = plan.amount < remaining ? plan.amount : remaining;
+              const withdrawStr = (Number(toWithdraw) / 1e6).toFixed(6);
+              console.log(`   [auto-yield] Withdrawing $${withdrawStr} yield from ${plan.collateralToken} market`);
+              const wr = await morphoClient.withdrawSupply(withdrawStr, plan.collateralToken);
+              lastTx = wr.tx;
+              totalWithdrawn += toWithdraw;
+              remaining -= toWithdraw;
+            }
+            if (totalWithdrawn > 0n) {
+              drawInfo.yieldWithdrawn = (Number(totalWithdrawn) / 1e6).toFixed(6);
+              drawInfo.yieldTx = lastTx;
+              console.log(`   [auto-yield] Withdrawn: $${drawInfo.yieldWithdrawn}`);
+            }
+          }
+          if (deficitAfterYield > 0n && this.config.autoDraw) {
+            const borrowAmount = (Number(deficitAfterYield) / 1e6).toFixed(6);
+            console.log(`   [auto-draw] Borrowing ${borrowAmount} USDC from Morpho...`);
+            const borrowResult = await morphoClient.borrow(borrowAmount);
+            console.log(`   [auto-draw] Borrow tx: ${borrowResult.tx}`);
+            drawInfo.borrowed = borrowAmount;
+            drawInfo.borrowTx = borrowResult.tx;
+            this._trackSpending(deficitAfterYield);
+          }
+          const result = await this.request(url, fetchOpts);
+          return { ...result, autoDrawInfo: drawInfo };
         }
       }
       return this.request(url, fetchOpts);
     } catch (error) {
-      console.log(`   [auto-draw] Auto-draw check failed: ${error instanceof Error ? error.message : String(error)}. Proceeding with normal request.`);
+      console.log(`   [auto-fund] Failed: ${error instanceof Error ? error.message : String(error)}. Proceeding with normal request.`);
       return this.request(url, fetchOpts);
     }
   }
@@ -2359,48 +2531,26 @@ var X402Client = class {
       };
     }
   }
-  /** Track a new spending amount */
+  /** Track a new spending amount and notify the caller for persistence */
   _trackSpending(amount) {
     this._resetTrackerIfNewDay();
     this._spendingTracker.totalBorrowed += amount;
-  }
-  /**
-   * Check if a borrow amount is within spending limits.
-   * Considers both fixed daily limits and yield-limited spending.
-   */
-  async _checkSpendingLimit(amount, morphoClient) {
-    this._resetTrackerIfNewDay();
-    if (this.config.yieldLimitedSpending) {
+    if (this.config.onSpendingUpdate) {
       try {
-        const status = await morphoClient.getStatus();
-        let totalDailyYieldUsdc = 0;
-        for (const pos of status.positions) {
-          if (parseFloat(pos.collateral) > 0) {
-            try {
-              const estimate = await morphoClient.getYieldEstimate(
-                pos.collateralToken,
-                pos.collateral,
-                1
-                // 1 day
-              );
-              totalDailyYieldUsdc += estimate.estimatedYieldUsd;
-            } catch (e) {
-              console.warn(`[agether] yield calc failed for ${pos.collateralToken}:`, e instanceof Error ? e.message : e);
-            }
-          }
-        }
-        const yieldLimit = BigInt(Math.round(totalDailyYieldUsdc * 1e6));
-        const newTotal = this._spendingTracker.totalBorrowed + amount;
-        if (yieldLimit > 0n && newTotal > yieldLimit) {
-          return {
-            allowed: false,
-            reason: `Yield-limited spending exceeded. Daily yield cap: $${(Number(yieldLimit) / 1e6).toFixed(2)}, already spent: $${(Number(this._spendingTracker.totalBorrowed) / 1e6).toFixed(2)}, requested: $${(Number(amount) / 1e6).toFixed(2)}`
-          };
-        }
+        this.config.onSpendingUpdate({
+          date: this._spendingTracker.date,
+          totalBorrowed: this._spendingTracker.totalBorrowed.toString()
+        });
       } catch (e) {
-        console.warn("[agether] yield-limited spending check failed, falling through to fixed limit:", e instanceof Error ? e.message : e);
+        console.warn("[agether] onSpendingUpdate callback failed:", e instanceof Error ? e.message : e);
       }
     }
+  }
+  /**
+   * Check if a borrow amount is within the fixed daily spending limit.
+   */
+  async _checkSpendingLimit(amount, _morphoClient) {
+    this._resetTrackerIfNewDay();
     if (this._spendingTracker.dailyLimit > 0n) {
       const newTotal = this._spendingTracker.totalBorrowed + amount;
       if (newTotal > this._spendingTracker.dailyLimit) {