@agether/sdk 2.4.0 → 2.6.0

package/dist/cli.js

@@ -274,7 +274,7 @@ var MorphoClient_exports = {};
 __export(MorphoClient_exports, {
   MorphoClient: () => MorphoClient
 });
-var import_ethers, import_axios, BASE_COLLATERALS, MORPHO_API_URL, MODE_SINGLE, MODE_BATCH, morphoIface, erc20Iface, MorphoClient;
+var import_ethers, import_axios, MORPHO_API_URL, MODE_SINGLE, MODE_BATCH, morphoIface, erc20Iface, MorphoClient;
 var init_MorphoClient = __esm({
   "src/clients/MorphoClient.ts"() {
     "use strict";
@@ -283,11 +283,6 @@ var init_MorphoClient = __esm({
     init_types();
     init_abis();
     init_config();
-    BASE_COLLATERALS = {
-      WETH: { address: "0x4200000000000000000000000000000000000006", symbol: "WETH", decimals: 18 },
-      wstETH: { address: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452", symbol: "wstETH", decimals: 18 },
-      cbETH: { address: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22", symbol: "cbETH", decimals: 18 }
-    };
     MORPHO_API_URL = "https://api.morpho.org/graphql";
     MODE_SINGLE = "0x0000000000000000000000000000000000000000000000000000000000000000";
     MODE_BATCH = "0x0100000000000000000000000000000000000000000000000000000000000000";
@@ -296,6 +291,8 @@ var init_MorphoClient = __esm({
     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);
@@ -482,15 +479,16 @@ var init_MorphoClient = __esm({
         const usdc = new import_ethers.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_ethers.Contract(info.address, ERC20_ABI, this.provider);
             const bal = await token.balanceOf(eoaAddr);
-            eoaCollateral[symbol] = import_ethers.ethers.formatUnits(bal, info.decimals);
+            eoaCollateral[info.symbol] = import_ethers.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 = {
@@ -505,14 +503,14 @@ var init_MorphoClient = __esm({
           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_ethers.Contract(info.address, ERC20_ABI, this.provider);
               const bal = await token.balanceOf(acctAddr);
-              acctCollateral[symbol] = import_ethers.ethers.formatUnits(bal, info.decimals);
+              acctCollateral[info.symbol] = import_ethers.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 = {
@@ -539,6 +537,50 @@ var init_MorphoClient = __esm({
         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_ethers.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_ethers.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_ethers.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_ethers.ethers.parseEther(amount);
+        }
+        const receipt = await this.exec(eoaAddr, "0x", weiAmount);
+        const actualAmount = amount === "all" ? import_ethers.ethers.formatEther(weiAmount) : amount;
+        return { tx: receipt.hash, token: "ETH", amount: actualAmount, destination: eoaAddr };
+      }
       // ════════════════════════════════════════════════════════
       //  Market Discovery (Morpho GraphQL API)
       // ════════════════════════════════════════════════════════
@@ -598,6 +640,28 @@ var init_MorphoClient = __esm({
                 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_ethers.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;
@@ -611,8 +675,17 @@ var init_MorphoClient = __esm({
        * 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();
@@ -771,8 +844,17 @@ var init_MorphoClient = __esm({
         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 = `{
@@ -831,8 +913,7 @@ var init_MorphoClient = __esm({
        * @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");
@@ -1134,8 +1215,7 @@ var init_MorphoClient = __esm({
        */
       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_ethers.ethers.parseUnits(amount, colInfo.decimals);
         const morphoAddr = this.config.contracts.morphoBlue;
@@ -1256,8 +1336,7 @@ var init_MorphoClient = __esm({
        */
       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_ethers.ethers.parseUnits(collateralAmount, colInfo.decimals);
         const borrowWei = import_ethers.ethers.parseUnits(borrowUsdcAmount, 6);
@@ -1425,8 +1504,7 @@ var init_MorphoClient = __esm({
        */
       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;
@@ -1523,8 +1601,7 @@ var init_MorphoClient = __esm({
        * (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;
@@ -1780,6 +1857,43 @@ var init_MorphoClient = __esm({
         }
         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.
        *
@@ -1928,7 +2042,9 @@ var init_X402Client = __esm({
         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" });
@@ -1957,66 +2073,122 @@ var init_X402Client = __esm({
         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);
         }
       }
@@ -2117,48 +2289,26 @@ var init_X402Client = __esm({
           };
         }
       }
-      /** 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) {