@agether/sdk 2.13.0 → 2.14.0

package/dist/clients/X402Client.js

@@ -0,0 +1,438 @@
+/**
+ * x402 HTTP Client — Make paid API calls via the x402 protocol (v2)
+ *
+ * Built on top of the official @x402/fetch + @x402/evm SDK.
+ * https://docs.x402.org/getting-started/quickstart-for-buyers
+ *
+ * Flow:
+ *   1. Client → Resource Server (normal request)
+ *   2. Resource Server → 402 with PAYMENT-REQUIRED header (base64 JSON)
+ *   3. @x402/fetch auto-picks PaymentRequirements, signs EIP-3009 via EVM scheme
+ *   4. Client → Resource Server (retries with PAYMENT-SIGNATURE header)
+ *   5. Resource Server → verifies via facilitator → settles → 200 + data
+ *
+ * Auto-Draw: When autoDraw is enabled and USDC balance is insufficient,
+ * the client automatically borrows from Morpho Blue before paying.
+ *
+ * Auto-Yield: When autoYield is enabled, the client first tries to cover
+ * the deficit from earned supply yield (principal untouched) before borrowing.
+ *
+ * Waterfall when both enabled: balance → yield → borrow
+ *
+ * Spending Limits: Optional daily spending cap (dailySpendLimitUsdc) with
+ * persistent state via onSpendingUpdate callback. The caller (e.g. plugin)
+ * is responsible for persisting and restoring state via initialSpendingState.
+ *
+ * Chain support: Base (8453), Base Sepolia (84532), Ethereum (1).
+ */
+import { wrapFetchWithPayment } from '@x402/fetch';
+import { x402Client } from '@x402/core/client';
+import { registerExactEvmScheme } from '@x402/evm/exact/client';
+import { privateKeyToAccount, toAccount } from 'viem/accounts';
+// ──────────────────── Client ────────────────────
+export class X402Client {
+    constructor(config) {
+        this.config = config;
+        // ── Step 1: Resolve base signer from privateKey or walletClient ──
+        let baseSigner;
+        if ('walletClient' in config && config.walletClient) {
+            // External WalletClient mode (Privy, Turnkey, MetaMask, etc.)
+            const wc = config.walletClient;
+            const account = wc.account;
+            if (!account) {
+                throw new Error('X402Client: walletClient must have an attached account. ' +
+                    'Pass an account when creating the WalletClient or use privateKey mode instead.');
+            }
+            this.address = account.address;
+            // Adapt WalletClient to the signer interface expected by @x402/evm
+            baseSigner = {
+                address: account.address,
+                signTypedData: (msg) => wc.signTypedData({
+                    account,
+                    domain: msg.domain,
+                    types: msg.types,
+                    primaryType: msg.primaryType,
+                    message: msg.message,
+                }),
+            };
+        }
+        else if ('privateKey' in config && config.privateKey) {
+            // Private key mode (existing behavior — SDK manages wallet)
+            const privateKey = config.privateKey.startsWith('0x')
+                ? config.privateKey
+                : `0x${config.privateKey}`;
+            const account = privateKeyToAccount(privateKey);
+            this.address = account.address;
+            baseSigner = account;
+        }
+        else {
+            throw new Error('X402Client: provide either privateKey or walletClient in config.');
+        }
+        // ── Step 2: Wrap signer for smart-wallet (AgentAccount) if accountAddress is set ──
+        // When accountAddress is provided, EIP-3009 `from` must be the contract, and
+        // the signature must be >65 bytes so the x402 facilitator routes through USDC's
+        // `bytes signature` overload of transferWithAuthorization — triggering EIP-1271
+        // `isValidSignature` on the AgentAccount contract.
+        let signer;
+        if (config.accountAddress) {
+            const accountAddr = config.accountAddress;
+            const inner = baseSigner;
+            signer = toAccount({
+                address: accountAddr,
+                async signMessage({ message }) {
+                    if ('signMessage' in inner && typeof inner.signMessage === 'function') {
+                        return inner.signMessage({ message });
+                    }
+                    throw new Error('signMessage not supported by underlying signer');
+                },
+                async signTransaction(tx) {
+                    if ('signTransaction' in inner && typeof inner.signTransaction === 'function') {
+                        return inner.signTransaction(tx);
+                    }
+                    throw new Error('signTransaction not supported by underlying signer');
+                },
+                async signTypedData(typedData) {
+                    const sig = await inner.signTypedData(typedData);
+                    // For Safe7579: prepend validator module address so isValidSignature
+                    // routes through Safe7579 → validator.isValidSignatureWithSender()
+                    if (config.validatorModule) {
+                        const validatorHex = config.validatorModule.replace('0x', '').toLowerCase();
+                        const sigHex = sig.replace('0x', '');
+                        return `0x${validatorHex}${sigHex}`;
+                    }
+                    // Fallback: append 00 to trigger EIP-1271 via >65 byte sig
+                    return `${sig}00`;
+                },
+            });
+            this.address = accountAddr;
+        }
+        else {
+            signer = baseSigner;
+        }
+        // Create x402 client and register EVM scheme (handles EIP-3009 signing)
+        const client = new x402Client();
+        registerExactEvmScheme(client, { signer });
+        // Wrap native fetch with automatic 402 payment handling
+        this.paidFetch = wrapFetchWithPayment(fetch, client);
+        // Initialize spending tracker (restore from cache if provided)
+        const today = new Date().toISOString().split('T')[0];
+        const dailyLimit = config.dailySpendLimitUsdc
+            ? BigInt(Math.round(parseFloat(config.dailySpendLimitUsdc) * 1e6))
+            : 0n;
+        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' });
+    }
+    async post(url, body, opts) {
+        return this.request(url, {
+            ...opts,
+            method: 'POST',
+            body: body ? JSON.stringify(body) : undefined,
+            headers: { 'Content-Type': 'application/json', ...opts?.headers },
+        });
+    }
+    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-funding: Make an x402 request with automatic USDC sourcing.
+     *
+     * 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 neither auto mode enabled or no morphoClient, fall back to normal request
+        if ((!this.config.autoDraw && !this.config.autoYield) || !morphoClient) {
+            return this.request(url, fetchOpts);
+        }
+        try {
+            // ── Step 1: Check current USDC balance on AgentAccount ──
+            const usdcBalance = await morphoClient.getUsdcBalance();
+            console.log(`   [auto-fund] AgentAccount USDC balance: ${(Number(usdcBalance) / 1e6).toFixed(2)}`);
+            // ── Step 2: Probe the URL to discover payment amount ──
+            const paymentAmount = await this._probePaymentAmount(url, fetchOpts);
+            if (paymentAmount !== null) {
+                console.log(`   [auto-fund] Payment required: ${(Number(paymentAmount) / 1e6).toFixed(6)} USDC`);
+                const needed = paymentAmount;
+                if (usdcBalance < needed) {
+                    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) > 0.000001)
+                                .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)}`);
+                        }
+                    }
+                    // Plan: how much yield do we actually need to withdraw?
+                    const yieldToUse = totalYieldAvailable < totalDeficit ? totalYieldAvailable : totalDeficit;
+                    const deficitAfterYield = totalDeficit - yieldToUse;
+                    // Plan: how much do we need to borrow?
+                    let canBorrow = 0n;
+                    if (this.config.autoDraw && deficitAfterYield > 0n) {
+                        // Check spending limit first
+                        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`);
+                    }
+                    // ── Feasibility check: can yield + borrow cover full deficit? ──
+                    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: `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)}.`,
+                        };
+                    }
+                    // ═══════════════════════════════════════════
+                    //  EXECUTION PHASE — plan is feasible, execute
+                    // ═══════════════════════════════════════════
+                    const drawInfo = {
+                        reason: `USDC balance insufficient (had ${(Number(usdcBalance) / 1e6).toFixed(2)}, needed ${(Number(needed) / 1e6).toFixed(2)})`,
+                    };
+                    // Execute: withdraw yield (only the amount we planned)
+                    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}`);
+                        }
+                    }
+                    // Execute: borrow remaining deficit
+                    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);
+                    }
+                    // Execute: proceed with payment
+                    const result = await this.request(url, fetchOpts);
+                    return { ...result, autoDrawInfo: drawInfo };
+                }
+            }
+            // Balance sufficient or couldn't determine amount — proceed normally
+            return this.request(url, fetchOpts);
+        }
+        catch (error) {
+            console.log(`   [auto-fund] 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 {
+            console.log(`   [x402] ${options?.method || 'GET'} ${url}`);
+            const response = await this.paidFetch(url, {
+                ...options,
+                headers: {
+                    ...options?.headers,
+                    'X-Agent-Id': this.config.agentId || '',
+                },
+            });
+            if (response.ok) {
+                const data = await response.json();
+                // Check for settlement response header
+                const paymentResponse = response.headers.get('PAYMENT-RESPONSE');
+                let txHash;
+                let settlementNetwork;
+                if (paymentResponse) {
+                    try {
+                        const settlement = JSON.parse(Buffer.from(paymentResponse, 'base64').toString('utf-8'));
+                        txHash = settlement.transaction;
+                        settlementNetwork = settlement.network;
+                    }
+                    catch (e) {
+                        console.warn('[agether] x402 payment response parse failed:', e instanceof Error ? e.message : e);
+                    }
+                }
+                return {
+                    success: true,
+                    data,
+                    ...(txHash ? {
+                        paymentInfo: {
+                            amount: '',
+                            asset: 'USDC',
+                            network: settlementNetwork || 'eip155',
+                            txHash,
+                        },
+                    } : {}),
+                };
+            }
+            // If we get here, @x402/fetch already tried to pay but the server rejected
+            const errBody = await response.text();
+            return {
+                success: false,
+                error: `HTTP ${response.status}: ${errBody}`,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: `Request failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    // ──────────── 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;
+            // Parse PAYMENT-REQUIRED header (base64 JSON)
+            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 (e) {
+                console.warn('[agether] x402 payment header parse failed:', e instanceof Error ? e.message : e);
+            }
+            return null;
+        }
+        catch (e) {
+            console.warn('[agether] x402 getPaymentRequired failed:', e instanceof Error ? e.message : e);
+            return null;
+        }
+    }
+    /** Reset spending tracker if it's a new day */
+    _resetTrackerIfNewDay() {
+        const today = 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 and notify the caller for persistence */
+    _trackSpending(amount) {
+        this._resetTrackerIfNewDay();
+        this._spendingTracker.totalBorrowed += amount;
+        // Notify caller so they can persist the updated state
+        if (this.config.onSpendingUpdate) {
+            try {
+                this.config.onSpendingUpdate({
+                    date: this._spendingTracker.date,
+                    totalBorrowed: this._spendingTracker.totalBorrowed.toString(),
+                });
+            }
+            catch (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();
+        // Check fixed daily limit
+        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 };
+    }
+}

package/dist/index.d.mts

@@ -633,6 +633,89 @@ declare class MorphoClient {
         lltv: string;
         marketId: string;
     }>>;
+    /**
+     * Search Morpho markets by token name using the Morpho GraphQL API `search` field.
+     * No hardcoded token lists — uses Morpho's built-in fuzzy search.
+     *
+     * @param search - token name or symbol (e.g. 'WETH', 'staked ETH', 'ezETH')
+     * @param options.asCollateral - only return markets where the searched token is collateral
+     * @param options.asLoanToken - only return markets where the searched token is the loan asset
+     */
+    searchMarkets(search: string, options?: {
+        asCollateral?: boolean;
+        asLoanToken?: boolean;
+    }): Promise<Array<{
+        collateralToken: string;
+        loanToken: string;
+        loanDecimals: number;
+        collateralDecimals: number;
+        supplyApy: number;
+        borrowApy: number;
+        utilization: number;
+        totalSupplyUsd: number;
+        totalBorrowUsd: number;
+        lltv: string;
+        marketId: string;
+        collateralAddress: string;
+        loanAddress: string;
+    }>>;
+    /**
+     * Scan the AgentAccount wallet for all ERC-20 tokens that appear in Morpho
+     * markets on the current chain. Returns tokens where balance > 0.
+     *
+     * Uses the full market list (500 markets) to discover all relevant tokens,
+     * then checks on-chain balance for each unique token address.
+     *
+     * @returns Array of tokens with non-zero balance, sorted by balance descending.
+     */
+    getWalletTokenBalances(): Promise<Array<{
+        symbol: string;
+        address: string;
+        decimals: number;
+        balance: bigint;
+        balanceFormatted: string;
+    }>>;
+    /**
+     * Find borrowing opportunities for the agent.
+     *
+     * - If `collateralSymbol` is provided: find all markets where that token is collateral.
+     * - If omitted: scan wallet balances and find markets for each token the agent holds.
+     *
+     * Returns markets grouped by collateral token with APY, liquidity, and balance info.
+     *
+     * @param collateralSymbol - optional, e.g. 'WETH'. If omitted, scans wallet.
+     */
+    findBorrowingOptions(collateralSymbol?: string): Promise<Array<{
+        collateralToken: string;
+        collateralBalance: string;
+        markets: Array<{
+            loanToken: string;
+            borrowApy: string;
+            supplyApy: string;
+            lltv: string;
+            utilization: string;
+            availableLiquidity: string;
+            marketId: string;
+        }>;
+    }>>;
+    /**
+     * Find supply/lending opportunities for a specific loan token.
+     *
+     * "What can I supply to earn WETH?" → shows all markets where WETH is the loan token
+     * (user supplies WETH to earn yield from borrowers).
+     *
+     * @param loanTokenSymbol - e.g. 'USDC', 'WETH'
+     */
+    findSupplyOptions(loanTokenSymbol: string): Promise<Array<{
+        collateralToken: string;
+        loanToken: string;
+        supplyApy: string;
+        borrowApy: string;
+        lltv: string;
+        utilization: string;
+        totalSupply: string;
+        marketId: string;
+    }>>;
     /**
      * Estimate theoretical yield for a given collateral amount over a period.
      *

package/dist/index.d.ts

@@ -633,6 +633,89 @@ declare class MorphoClient {
         lltv: string;
         marketId: string;
     }>>;
+    /**
+     * Search Morpho markets by token name using the Morpho GraphQL API `search` field.
+     * No hardcoded token lists — uses Morpho's built-in fuzzy search.
+     *
+     * @param search - token name or symbol (e.g. 'WETH', 'staked ETH', 'ezETH')
+     * @param options.asCollateral - only return markets where the searched token is collateral
+     * @param options.asLoanToken - only return markets where the searched token is the loan asset
+     */
+    searchMarkets(search: string, options?: {
+        asCollateral?: boolean;
+        asLoanToken?: boolean;
+    }): Promise<Array<{
+        collateralToken: string;
+        loanToken: string;
+        loanDecimals: number;
+        collateralDecimals: number;
+        supplyApy: number;
+        borrowApy: number;
+        utilization: number;
+        totalSupplyUsd: number;
+        totalBorrowUsd: number;
+        lltv: string;
+        marketId: string;
+        collateralAddress: string;
+        loanAddress: string;
+    }>>;
+    /**
+     * Scan the AgentAccount wallet for all ERC-20 tokens that appear in Morpho
+     * markets on the current chain. Returns tokens where balance > 0.
+     *
+     * Uses the full market list (500 markets) to discover all relevant tokens,
+     * then checks on-chain balance for each unique token address.
+     *
+     * @returns Array of tokens with non-zero balance, sorted by balance descending.
+     */
+    getWalletTokenBalances(): Promise<Array<{
+        symbol: string;
+        address: string;
+        decimals: number;
+        balance: bigint;
+        balanceFormatted: string;
+    }>>;
+    /**
+     * Find borrowing opportunities for the agent.
+     *
+     * - If `collateralSymbol` is provided: find all markets where that token is collateral.
+     * - If omitted: scan wallet balances and find markets for each token the agent holds.
+     *
+     * Returns markets grouped by collateral token with APY, liquidity, and balance info.
+     *
+     * @param collateralSymbol - optional, e.g. 'WETH'. If omitted, scans wallet.
+     */
+    findBorrowingOptions(collateralSymbol?: string): Promise<Array<{
+        collateralToken: string;
+        collateralBalance: string;
+        markets: Array<{
+            loanToken: string;
+            borrowApy: string;
+            supplyApy: string;
+            lltv: string;
+            utilization: string;
+            availableLiquidity: string;
+            marketId: string;
+        }>;
+    }>>;
+    /**
+     * Find supply/lending opportunities for a specific loan token.
+     *
+     * "What can I supply to earn WETH?" → shows all markets where WETH is the loan token
+     * (user supplies WETH to earn yield from borrowers).
+     *
+     * @param loanTokenSymbol - e.g. 'USDC', 'WETH'
+     */
+    findSupplyOptions(loanTokenSymbol: string): Promise<Array<{
+        collateralToken: string;
+        loanToken: string;
+        supplyApy: string;
+        borrowApy: string;
+        lltv: string;
+        utilization: string;
+        totalSupply: string;
+        marketId: string;
+    }>>;
     /**
      * Estimate theoretical yield for a given collateral amount over a period.
      *

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,YAAY,EACV,oBAAoB,EACpB,cAAc,EACd,yBAAyB,EACzB,cAAc,GACf,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,YAAY,EACZ,cAAc,EACd,YAAY,EACZ,aAAa,EACb,YAAY,EACZ,sBAAsB,EACtB,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,YAAY,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAEnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,YAAY,EAAE,0BAA0B,EAAE,MAAM,+BAA+B,CAAC;AAEhF,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,YAAY,EAAE,iBAAiB,EAAE,UAAU,EAAE,YAAY,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAI9H,cAAc,SAAS,CAAC;AAIxB,OAAO,EACL,UAAU,EACV,WAAW,EACX,SAAS,EACT,aAAa,EACb,SAAS,EACT,kBAAkB,EAClB,aAAa,EACb,eAAe,EACf,SAAS,EACT,SAAS,GACV,MAAM,gBAAgB,CAAC;AAIxB,OAAO,EACL,qBAAqB,EAErB,wBAAwB,EACxB,kCAAkC,EAClC,4BAA4B,EAC5B,uBAAuB,EAEvB,sBAAsB,EACtB,mBAAmB,EACnB,6BAA6B,EAC7B,oBAAoB,EACpB,oBAAoB,EAEpB,uBAAuB,EACvB,eAAe,EACf,SAAS,EACT,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,cAAc,CAAC;AAItB,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,oBAAoB,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC"}