@agether/sdk 1.6.0 → 1.6.2

package/dist/index.js

@@ -760,6 +760,179 @@ var MorphoClient = class {
     };
   }
   // ════════════════════════════════════════════════════════
+  //  Balance & Borrowing Capacity
+  // ════════════════════════════════════════════════════════
+  /**
+   * Get the USDC balance of the AgentAccount.
+   * @returns USDC balance in raw units (6 decimals)
+   */
+  async getUsdcBalance() {
+    const acctAddr = await this.getAccountAddress();
+    const usdc = new import_ethers2.Contract(this.config.contracts.usdc, ERC20_ABI, this.provider);
+    return usdc.balanceOf(acctAddr);
+  }
+  /**
+   * Calculate the maximum additional USDC that can be borrowed
+   * given the agent's current collateral and debt across all markets.
+   *
+   * For each market with collateral deposited:
+   *   maxBorrow = (collateralValue * LLTV) - currentDebt
+   *
+   * Uses the Morpho oracle to price collateral → loan token.
+   *
+   * @returns Maximum additional USDC borrowable (6 decimals)
+   */
+  async getMaxBorrowable() {
+    const acctAddr = await this.getAccountAddress();
+    const markets = await this.getMarkets();
+    let totalAdditional = 0n;
+    const byMarket = [];
+    for (const m of markets) {
+      if (!m.collateralAsset || m.collateralAsset.address === import_ethers2.ethers.ZeroAddress) continue;
+      try {
+        const pos = await this.morphoBlue.position(m.uniqueKey, acctAddr);
+        if (pos.collateral === 0n) continue;
+        const mktState = await this.morphoBlue.market(m.uniqueKey);
+        const totalBorrowShares = BigInt(mktState.totalBorrowShares);
+        const totalBorrowAssets = BigInt(mktState.totalBorrowAssets);
+        const currentDebt = totalBorrowShares > 0n ? BigInt(pos.borrowShares) * totalBorrowAssets / totalBorrowShares : 0n;
+        let collateralValueInLoan;
+        try {
+          const oracleContract = new import_ethers2.Contract(m.oracle, [
+            "function price() view returns (uint256)"
+          ], this.provider);
+          const oraclePrice = await oracleContract.price();
+          const ORACLE_PRICE_SCALE = 10n ** 36n;
+          collateralValueInLoan = BigInt(pos.collateral) * oraclePrice / ORACLE_PRICE_SCALE;
+        } catch {
+          continue;
+        }
+        const maxBorrowTotal = collateralValueInLoan * m.lltv / 10n ** 18n;
+        const maxAdditional = maxBorrowTotal > currentDebt ? maxBorrowTotal - currentDebt : 0n;
+        totalAdditional += maxAdditional;
+        byMarket.push({
+          collateralToken: m.collateralAsset.symbol,
+          maxAdditional,
+          currentDebt,
+          collateralValue: collateralValueInLoan
+        });
+      } catch {
+        continue;
+      }
+    }
+    return { total: totalAdditional, byMarket };
+  }
+  // ════════════════════════════════════════════════════════
+  //  Market Rates & Yield Estimation
+  // ════════════════════════════════════════════════════════
+  /**
+   * Fetch current supply/borrow APY for a collateral market from Morpho GraphQL API.
+   *
+   * Note: On Morpho Blue, collateral does NOT earn yield directly. Supply APY
+   * is what lenders earn; borrow APY is what borrowers pay.
+   */
+  async getMarketRates(collateralSymbolOrAddress) {
+    const chainId = this.config.chainId;
+    const usdcAddr = this.config.contracts.usdc.toLowerCase();
+    let collateralFilter = "";
+    if (collateralSymbolOrAddress) {
+      const colInfo = BASE_COLLATERALS[collateralSymbolOrAddress];
+      const colAddr = (colInfo?.address ?? collateralSymbolOrAddress).toLowerCase();
+      collateralFilter = `, collateralAssetAddress_in: ["${colAddr}"]`;
+    }
+    const query = `{
+      markets(
+        first: 50
+        orderBy: SupplyAssetsUsd
+        orderDirection: Desc
+        where: { chainId_in: [${chainId}], loanAssetAddress_in: ["${usdcAddr}"]${collateralFilter} }
+      ) {
+        items {
+          uniqueKey
+          lltv
+          loanAsset { address symbol decimals }
+          collateralAsset { address symbol decimals }
+          state {
+            borrowAssets
+            supplyAssets
+            utilization
+            supplyApy
+            borrowApy
+          }
+        }
+      }
+    }`;
+    try {
+      const resp = await import_axios.default.post(MORPHO_API_URL, { query }, { timeout: 1e4 });
+      const items = resp.data?.data?.markets?.items ?? [];
+      return items.filter((m) => m.collateralAsset?.address && m.collateralAsset.address !== import_ethers2.ethers.ZeroAddress).map((m) => ({
+        collateralToken: m.collateralAsset.symbol,
+        loanToken: m.loanAsset.symbol,
+        supplyApy: m.state?.supplyApy ? Number(m.state.supplyApy) : 0,
+        borrowApy: m.state?.borrowApy ? Number(m.state.borrowApy) : 0,
+        utilization: m.state?.utilization ? Number(m.state.utilization) : 0,
+        totalSupplyUsd: m.state?.supplyAssets ? Number(m.state.supplyAssets) / 1e6 : 0,
+        totalBorrowUsd: m.state?.borrowAssets ? Number(m.state.borrowAssets) / 1e6 : 0,
+        lltv: `${(Number(m.lltv) / 1e16).toFixed(0)}%`,
+        marketId: m.uniqueKey
+      }));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * Estimate theoretical yield for a given collateral amount over a period.
+   *
+   * ⚠️ IMPORTANT: On Morpho Blue, collateral does NOT earn yield directly.
+   * This estimates what the collateral WOULD earn if it were instead supplied
+   * as a lender (not used as collateral). This is a theoretical upper bound
+   * useful for setting spending caps.
+   *
+   * @param collateralSymbol - e.g. 'WETH'
+   * @param amount - collateral amount in human-readable (e.g. '1.5')
+   * @param periodDays - estimation period in days (default: 1)
+   * @param ethPriceUsd - ETH price in USD for value conversion (if not provided, uses oracle)
+   * @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 rates = await this.getMarketRates(collateralSymbol);
+    if (rates.length === 0) {
+      throw new AgetherError(`No market found for ${collateralSymbol}`, "MARKET_NOT_FOUND");
+    }
+    const market = rates[0];
+    const supplyApy = market.supplyApy;
+    let collateralValueUsd;
+    if (ethPriceUsd) {
+      collateralValueUsd = parseFloat(amount) * ethPriceUsd;
+    } else {
+      try {
+        const params = await this.findMarketForCollateral(collateralSymbol);
+        const oracleContract = new import_ethers2.Contract(params.oracle, [
+          "function price() view returns (uint256)"
+        ], this.provider);
+        const oraclePrice = await oracleContract.price();
+        const ORACLE_PRICE_SCALE = 10n ** 36n;
+        const amountWei = import_ethers2.ethers.parseUnits(amount, colInfo.decimals);
+        const valueInUsdc = amountWei * oraclePrice / ORACLE_PRICE_SCALE;
+        collateralValueUsd = Number(valueInUsdc) / 1e6;
+      } catch {
+        throw new AgetherError("Cannot determine collateral value. Provide ethPriceUsd.", "PRICE_UNAVAILABLE");
+      }
+    }
+    const estimatedYieldUsd = collateralValueUsd * supplyApy * (periodDays / 365);
+    return {
+      collateralToken: collateralSymbol,
+      amount,
+      periodDays,
+      theoreticalSupplyApy: supplyApy,
+      estimatedYieldUsd,
+      collateralValueUsd,
+      disclaimer: "Collateral on Morpho Blue does NOT earn yield directly. This estimates what it WOULD earn if supplied as a lender instead. Use as a theoretical spending cap."
+    };
+  }
+  // ════════════════════════════════════════════════════════
   //  Lending Operations (all via AgentAccount.executeBatch)
   // ════════════════════════════════════════════════════════
   /**
@@ -891,7 +1064,6 @@ var MorphoClient = class {
    */
   async repay(usdcAmount, tokenSymbol, marketParams) {
     const acctAddr = await this.getAccountAddress();
-    const amount = import_ethers2.ethers.parseUnits(usdcAmount, 6);
     const morphoAddr = this.config.contracts.morphoBlue;
     const usdcAddr = this.config.contracts.usdc;
     let params;
@@ -903,14 +1075,60 @@ var MorphoClient = class {
       const { params: p } = await this._findActiveMarket();
       params = p;
     }
+    let repayAssets;
+    let repayShares;
+    let approveAmount;
+    if (usdcAmount === "all") {
+      const markets = await this.getMarkets();
+      const mkt = markets.find(
+        (m) => m.collateralAsset?.address.toLowerCase() === params.collateralToken.toLowerCase()
+      );
+      if (mkt) {
+        const pos = await this.morphoBlue.position(mkt.uniqueKey, acctAddr);
+        repayShares = BigInt(pos.borrowShares);
+        repayAssets = 0n;
+        const onChainMkt = await this.morphoBlue.market(mkt.uniqueKey);
+        const totalBorrowAssets = BigInt(onChainMkt.totalBorrowAssets);
+        const totalBorrowShares = BigInt(onChainMkt.totalBorrowShares);
+        const estimated = totalBorrowShares > 0n ? repayShares * totalBorrowAssets / totalBorrowShares + 10n : 0n;
+        approveAmount = estimated > 0n ? estimated : import_ethers2.ethers.parseUnits("1", 6);
+      } else {
+        repayAssets = import_ethers2.ethers.parseUnits("999999", 6);
+        repayShares = 0n;
+        approveAmount = repayAssets;
+      }
+    } else {
+      repayAssets = import_ethers2.ethers.parseUnits(usdcAmount, 6);
+      repayShares = 0n;
+      approveAmount = repayAssets;
+      try {
+        const markets = await this.getMarkets();
+        const mkt = markets.find(
+          (m) => m.collateralAsset?.address.toLowerCase() === params.collateralToken.toLowerCase()
+        );
+        if (mkt) {
+          const pos = await this.morphoBlue.position(mkt.uniqueKey, acctAddr);
+          const onChainMkt = await this.morphoBlue.market(mkt.uniqueKey);
+          const totalBorrowAssets = BigInt(onChainMkt.totalBorrowAssets);
+          const totalBorrowShares = BigInt(onChainMkt.totalBorrowShares);
+          const currentDebt = totalBorrowShares > 0n ? BigInt(pos.borrowShares) * totalBorrowAssets / totalBorrowShares : 0n;
+          if (repayAssets >= currentDebt && BigInt(pos.borrowShares) > 0n) {
+            repayShares = BigInt(pos.borrowShares);
+            repayAssets = 0n;
+            approveAmount = currentDebt + 10n;
+          }
+        }
+      } catch {
+      }
+    }
     const targets = [usdcAddr, morphoAddr];
     const values = [0n, 0n];
     const datas = [
-      erc20Iface.encodeFunctionData("approve", [morphoAddr, amount]),
+      erc20Iface.encodeFunctionData("approve", [morphoAddr, approveAmount]),
       morphoIface.encodeFunctionData("repay", [
         this._toTuple(params),
-        amount,
-        0n,
+        repayAssets,
+        repayShares,
         acctAddr,
         "0x"
       ])
@@ -1107,6 +1325,9 @@ var X402Client = class {
     const client = new import_client.x402Client();
     (0, import_client2.registerExactEvmScheme)(client, { signer });
     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 };
   }
   async get(url, opts) {
     return this.request(url, { ...opts, method: "GET" });
@@ -1122,6 +1343,82 @@ var X402Client = class {
   getAddress() {
     return this.address;
   }
+  /** Get the current spending tracker state */
+  getSpendingTracker() {
+    this._resetTrackerIfNewDay();
+    return { ...this._spendingTracker };
+  }
+  /** Get remaining daily spending allowance in USDC (human-readable) */
+  getRemainingDailyAllowance() {
+    this._resetTrackerIfNewDay();
+    if (this._spendingTracker.dailyLimit === 0n) return "unlimited";
+    const remaining = this._spendingTracker.dailyLimit - this._spendingTracker.totalBorrowed;
+    return (Number(remaining > 0n ? remaining : 0n) / 1e6).toFixed(2);
+  }
+  /**
+   * Pay with auto-draw: Make an x402 request with automatic Morpho borrowing.
+   *
+   * 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
+   */
+  async payWithAutoDraw(url, opts) {
+    const { morphoClient, ...fetchOpts } = opts || {};
+    if (!this.config.autoDraw || !morphoClient) {
+      return this.request(url, fetchOpts);
+    }
+    try {
+      const usdcBalance = await morphoClient.getUsdcBalance();
+      console.log(`   [auto-draw] 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`);
+        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 maxBorrowable = await morphoClient.getMaxBorrowable();
+          if (maxBorrowable.total < deficit) {
+            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.`
+            };
+          }
+          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)})`
+            }
+          };
+        }
+      }
+      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.`);
+      return this.request(url, fetchOpts);
+    }
+  }
   // ──────────── Core request — @x402/fetch handles 402 automatically ────────────
   async request(url, options) {
     try {
@@ -1171,6 +1468,102 @@ var X402Client = class {
       };
     }
   }
+  // ──────────── Auto-Draw Helpers ────────────
+  /**
+   * Probe a URL to discover payment requirements without paying.
+   * Makes a request and parses the 402 PAYMENT-REQUIRED header.
+   * @returns Payment amount in raw USDC units (6 decimals), or null if not a 402.
+   */
+  async _probePaymentAmount(url, options) {
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          ...options?.headers,
+          "X-Agent-Id": this.config.agentId || ""
+        }
+      });
+      if (response.status !== 402) return null;
+      const paymentHeader = response.headers.get("X-PAYMENT") || response.headers.get("PAYMENT-REQUIRED");
+      if (!paymentHeader) return null;
+      try {
+        const decoded = JSON.parse(Buffer.from(paymentHeader, "base64").toString("utf-8"));
+        const requirements = Array.isArray(decoded) ? decoded : decoded.accepts || [decoded];
+        if (requirements.length > 0) {
+          const amount = requirements[0].maxAmountRequired || requirements[0].amount;
+          if (amount) {
+            return BigInt(amount);
+          }
+        }
+      } catch {
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  /** Reset spending tracker if it's a new day */
+  _resetTrackerIfNewDay() {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    if (this._spendingTracker.date !== today) {
+      this._spendingTracker = {
+        date: today,
+        totalBorrowed: 0n,
+        dailyLimit: this._spendingTracker.dailyLimit
+      };
+    }
+  }
+  /** Track a new spending amount */
+  _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) {
+      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 {
+            }
+          }
+        }
+        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)}`
+          };
+        }
+      } catch {
+      }
+    }
+    if (this._spendingTracker.dailyLimit > 0n) {
+      const newTotal = this._spendingTracker.totalBorrowed + amount;
+      if (newTotal > this._spendingTracker.dailyLimit) {
+        return {
+          allowed: false,
+          reason: `Daily spending limit exceeded. Limit: $${(Number(this._spendingTracker.dailyLimit) / 1e6).toFixed(2)}, already spent: $${(Number(this._spendingTracker.totalBorrowed) / 1e6).toFixed(2)}, requested: $${(Number(amount) / 1e6).toFixed(2)}`
+        };
+      }
+    }
+    return { allowed: true };
+  }
 };
 
 // src/clients/ScoringClient.ts