@continuumdao/ctm-mpc-defi 0.2.44 → 0.2.45

package/dist/agent/skills/hyperliquid/SKILL.md

@@ -22,8 +22,9 @@ The MPC **executor address** (`keyGen.ethereumaddress`) is the Hyperliquid **use
 - **Spot ↔ Perp:** USDC is one asset split between **spot** and **perp margin** ledgers (not separate ERC20s). Move with `usdClassTransfer`.
 - **Vaults:** Deposit/withdraw USD into protocol vaults (withdraw includes accrued PnL).
 - **Staking:** Stake/unstake **HYPE** and delegate to validators.
+- **Borrow / lend:** Manual HyperCore money market. Collateralize **HYPE** / **UBTC**; borrow or supply quote assets (**USDC**, **USDT0**, **USDH**). Current **supply APR** and **borrow APR** come from `ctm_hyperliquid_fetch_lend_markets`.
 
-Trading reads use Hyperliquid **REST `/info`**. Writes use **CoreWriter** on HyperEVM (not the signed `/exchange` API).
+Trading reads use Hyperliquid **REST `/info`**. Most writes use **CoreWriter** on HyperEVM. Leverage, bridge withdraw, TP/SL brackets, and **borrow/lend** use signed **L1 `/exchange`** (EIP-712).
 
 ## Getting started (funding)
 
@@ -45,7 +46,7 @@ Positions and orders from MCP reflect **live HyperCore state** after prior txs a
 5. `ctm_hyperliquid_fetch_market_snapshot({ chainId, coin: "AAPL" })` — **`livePrice.midUsd`** is the current price; **`funding`** is official hourly HyperCore funding; `latestCandle` is the most recent bar; `candles` is capped (default 48). Throws if live price cannot be fetched.
 6. `ctm_hyperliquid_fetch_open_context({ chainId, executorAddress, coin: "Apple" })` — same resolution
 7. `ctm_hyperliquid_fetch_usd_class_balances({ chainId, executorAddress })` — spot vs perp USD if needed
-8. **Gas** — `get_multi_sign_gas_options({ chainId })` + `useCustomGas` for **CoreWriter** tools only (plain limit, close, cancel, transfers, vault, stake). **Skip gas** for `build_update_leverage_multisign`, `build_bridge_withdraw_multisign`, and limit orders **with TP/SL triggers** (EIP-712 `/exchange`).
+8. **Gas** — `get_multi_sign_gas_options({ chainId })` + `useCustomGas` for **CoreWriter** tools only (plain limit, close, cancel, transfers, vault, stake). **Skip gas** for `build_update_leverage_multisign`, `build_bridge_withdraw_multisign`, `build_lend_multisign`, and limit orders **with TP/SL triggers** (EIP-712 `/exchange`).
 9. `ctm_hyperliquid_build_limit_order_multisign` → **`{ requestId }`**
 10. Base MPC lifecycle (shared gas/submit section below)
 
@@ -69,6 +70,8 @@ Positions and orders from MCP reflect **live HyperCore state** after prior txs a
 | User vault equity | `ctm_hyperliquid_fetch_user_vault_equities` |
 | HYPE stake summary | `ctm_hyperliquid_fetch_staking_summary` |
 | Validator delegations | `ctm_hyperliquid_fetch_delegations` |
+| Core lend markets + **current supply/borrow APR** | `ctm_hyperliquid_fetch_lend_markets` — activate `hyperliquid:lend` |
+| Core lend positions + health + manual-borrow gate | `ctm_hyperliquid_fetch_lend_positions` |
 
 ### Multi-sign (writes)
 
@@ -87,6 +90,7 @@ Positions and orders from MCP reflect **live HyperCore state** after prior txs a
 | Delegate to validator | `ctm_hyperliquid_build_delegate_multisign` |
 | Undelegate | `ctm_hyperliquid_build_undelegate_multisign` |
 | Update per-market leverage | `ctm_hyperliquid_build_update_leverage_multisign` (EIP-712 — no gas) |
+| Supply / withdraw / borrow / repay | `ctm_hyperliquid_build_lend_multisign` (EIP-712 — no gas) |
 
 ### EIP-712 vs CoreWriter (critical for agents)
 
@@ -95,6 +99,7 @@ Positions and orders from MCP reflect **live HyperCore state** after prior txs a
 | Plain limit / close / cancel / USD transfer / vault / stake | CoreWriter EVM tx | **Yes** — `get_multi_sign_gas_options`, pass `useCustomGas` |
 | `build_update_leverage_multisign` | EIP-712 → `/exchange` | **No** — trigger without txParams |
 | `build_bridge_withdraw_multisign` | EIP-712 → `/exchange` | **No** |
+| `build_lend_multisign` | EIP-712 → `/exchange` | **No** — trigger without txParams |
 | Limit with `takeProfitTriggerPxHuman` and/or `stopLossTriggerPxHuman` | EIP-712 normalTpsl → `/exchange` | **No** — re-build if entry/TP/SL change |
 
 ## Common multisign inputs (all `build_*` tools)
@@ -203,6 +208,31 @@ Use `isLong: true` for a **long** position (submits sell reduce-only IoC):
 
 Check balances first with `ctm_hyperliquid_fetch_usd_class_balances`.
 
+## Borrow / lend (HyperCore)
+
+Activate **`hyperliquid:lend`** (`activate_tool_group`). Do not fold this into vaults or perp market-data.
+
+1. `ctm_hyperliquid_fetch_lend_markets` — current **`supplyYearlyRate` / `borrowYearlyRate`** are **APR** (decimal; `0.05` = 5%). Also `supplyAprPercent` / `borrowAprPercent`. `role` is `collateral` (LTV > 0) or `quote`.
+2. `ctm_hyperliquid_fetch_lend_positions` — supplied/borrowed, `health`, `manualBorrowEnabled`. If `userAbstraction` is `portfolioMargin`, **do not** call `operation: "borrow"`.
+3. `ctm_hyperliquid_build_lend_multisign` with `operation`: `supply` | `withdraw` | `borrow` | `repay`.
+
+Rules:
+
+- **HYPE / UBTC** (`BTC` aliases to UBTC) supplied as collateral **do not earn interest**.
+- **USDC / USDT0** (`USDT` aliases to USDT0) / **USDH** supplied earn utilization APR but **do not increase borrow capacity**.
+- `amountMax: true` (or `amountHuman: "max"`) sends wire `amount: null` — full withdraw/repay.
+- EIP-712 `/exchange` — **no `useCustomGas`**, trigger without txParams.
+
+```json
+{
+  "chainId": 999,
+  "purposeText": "HL supply 100 USDC",
+  "coin": "USDC",
+  "operation": "supply",
+  "amountHuman": "100"
+}
+```
+
 ## Vault / stake
 
 - **Vault deposit/withdraw:** `vaultAddress` from `fetch_vaults`; `usdHuman` amount. Mainnet vault catalog fetch can take ~10–15s (large stats feed). Testnet catalog is empty.

package/dist/agent/skills/yield-compare/SKILL.md

@@ -11,10 +11,12 @@ Do **not** web-search rates. Do **not** use DefiLlama. HIP-3 / Arcus stock tradi
 
 ## Plan Mode
 
-If the operator started **Best yield** / plan mode `yield`: this thread **authors the plan file**. Ask for the asset first. Then `get_defi_protocol_skill({ protocolId: "yield-compare" })` **once** and write workstreams — do **not** `load_defi_protocol`, search Continuum tools, or spawn specialists on the parent. Execute runs one specialist per listed protocol. Research-only — no `ctm_*_build_*_multisign`. Table categories: `idle` / `lp` / `vault` / `perp_funding`. GMX and Hyperliquid only if they asked. Catalog MCP is context only.
+If the operator started **Best yield** / plan mode `yield`: this thread **authors the plan file**. Ask for the asset first. Then `get_defi_protocol_skill({ protocolId: "yield-compare" })` **once** and write workstreams — do **not** `load_defi_protocol`, search Continuum tools, or spawn specialists on the parent. Execute runs one specialist per listed protocol. Research-only — no `ctm_*_build_*_multisign`. Table categories: `idle` / `lp` / `vault` / `perp_funding`. GMX and Hyperliquid vaults/funding only if they asked. Hyperliquid **Core lend** (USDC/USDT supply APR) is an **optional extra** for stables — mention in plan notes; add an Execute leaf only if they say yes or already asked about Hyperliquid / HL lend / Core lending. Catalog MCP is context only.
 
 For **USDC / USDT**, the authored plan notes **must** mention Morpho stock-backed USDC loans as an **optional extra** (isolated Blue/Midnight books against Coinbase B20 collateral such as AAPLc/NVDAc; thin liquidity; 24/5 oracles; Regulation S / non-US). Do **not** add a Morpho stock Execute workstream or call `ctm_morpho_fetch_stock_markets` unless the operator says yes or already asked about stocks / tokenized stocks / stock-backed loans.
 
+For **USDC / USDT**, plan notes **must** also mention Hyperliquid Core lend as an **optional extra**: supply USDC/USDT0 on HyperCore to earn utilization **APR** (`ctm_hyperliquid_fetch_lend_markets`); HYPE/UBTC collateral earns nothing. Do **not** add a Hyperliquid Execute workstream or call `ctm_hyperliquid_fetch_lend_markets` unless the operator says yes or already asked about Hyperliquid / HL lend / Core lending. That leaf is research-only (`toolGroups: ["defi_discovery", "defi:hyperliquid:lend", "keygen", "keygen_messaging"]`) — report quote-token `supplyYearlyRate` as **APR** plus `borrowYearlyRate` as context; skip collateral rows; category `idle`. Do not treat Core lend as vault APR or perp funding.
+
 Each Execute protocol leaf must list `toolGroups: ["defi_discovery", "defi:<protocol>:market-data", "keygen", "keygen_messaging"]` (canonical ids: `aave-v4`, `compound-v3`, `euler-v2`, `morpho`, `maple-syrup`, `curve-dao`, `aerodrome`, `pendle`) and `budget: { maxRounds: 16, maxWallClockMs: 240000 }`. Slim leaves cannot search/activate packs — without `defi_discovery` they never see `load_defi_protocol` or official `ctm_*` fetch tools. Do **not** use `agent_bash` / `agent_read_file` / `agent_grep` on a yield leaf — call the official fetch (`ctm_aave_v4_fetch_markets`, `ctm_compound_v3_fetch_markets`, `ctm_morpho_fetch_earn_vaults`, `ctm_morpho_fetch_blue_markets` with `loan: "USDC"` / `"USDT"`, `ctm_aerodrome_fetch_lp_yields` on Base `8453`, `ctm_pendle_fetch_markets` / `ctm_pendle_search_assets`, …) then post `mpc-task-result`. Ticker filters (`underlying: "USDT"`, Morpho `loan: "USDC"`) are valid on Aave/Maple/Morpho fetches — do not invent ERC-20 addresses. Morpho leaf: report vault `netApy` and Blue `netSupplyApyLabel`; footnote `rewards[]` as variable extras — do not add them on top of net APY a second time. Skip empty Blue books (no supply TVL). `ctm_morpho_fetch_stock_markets` only after the operator says yes. Aave v4 is Ethereum-first (`1`; also 10 / 43114). Maple is Ethereum (`1`). Aerodrome is Base (`8453`) only. Pendle is any Core `chainId` ∩ node registry — research-only fetch, no build.
 
 ## Units and caveats
@@ -52,6 +54,7 @@ Call `get_defi_protocol_skill({ protocolId: "yield-compare" })` for this map, th
 3. `ctm_pendle_fetch_markets` — optional PT / YT / LP implied APY if they asked about Pendle (research-only)
 4. `ctm_gmx_fetch_gm_apy` / `ctm_hyperliquid_fetch_vault_apys` / perp funding — **only if they asked** about GMX, HL vaults, or funding
 5. Morpho stock-backed USDC loans — **optional extra in plan notes only**. Call `ctm_morpho_fetch_stock_markets` only if they say yes.
+6. Hyperliquid Core lend (`ctm_hyperliquid_fetch_lend_markets`) — **optional extra in plan notes**. Call only if they say yes or already asked about Hyperliquid / HL lend. Quote tokens only (USDC / USDT0); **APR** not APY. HYPE/UBTC collateral is not idle yield.
 
 ### USDS
 

package/dist/protocols/evm/hyperliquid/index.cjs

@@ -481,6 +481,49 @@ async function hyperliquidFetchStakingSummary(args) {
   });
   return { delegated: raw?.delegated ?? "0", undelegated: raw?.undelegated ?? "0" };
 }
+async function hyperliquidFetchSpotTokens(args) {
+  const meta = await hyperliquidInfoPost(args.chainId, { type: "spotMeta" });
+  const tokens = (meta.tokens ?? []).map((t) => ({
+    name: t.name,
+    tokenIndex: t.index,
+    szDecimals: t.szDecimals
+  }));
+  return { tokens };
+}
+async function hyperliquidFetchAllBorrowLendReserveStates(args) {
+  const raw = await hyperliquidInfoPost(args.chainId, {
+    type: "allBorrowLendReserveStates"
+  });
+  return { reserves: Array.isArray(raw) ? raw : [] };
+}
+async function hyperliquidFetchBorrowLendReserveState(args) {
+  const reserve = await hyperliquidInfoPost(args.chainId, {
+    type: "borrowLendReserveState",
+    token: args.token
+  });
+  return { reserve };
+}
+async function hyperliquidFetchBorrowLendUserState(args) {
+  const state = await hyperliquidInfoPost(args.chainId, {
+    type: "borrowLendUserState",
+    user: args.user
+  });
+  return {
+    state: {
+      tokenToState: Array.isArray(state?.tokenToState) ? state.tokenToState : [],
+      health: String(state?.health ?? "healthy"),
+      healthFactor: state?.healthFactor ?? null
+    }
+  };
+}
+async function hyperliquidFetchUserAbstraction(args) {
+  const raw = await hyperliquidInfoPost(args.chainId, {
+    type: "userAbstraction",
+    user: args.user
+  });
+  if (typeof raw === "string" && raw.trim()) return { abstraction: raw.trim() };
+  return { abstraction: "default" };
+}
 
 // src/protocols/evm/hyperliquid/marketSearch.ts
 function normalizeQuery(value) {
@@ -636,6 +679,21 @@ async function hyperliquidResolvePerpMarket(args) {
 }
 
 // src/protocols/evm/hyperliquid/assets.ts
+var HYPERLIQUID_LEND_TOKEN_ALIASES = {
+  btc: "UBTC",
+  ubtc: "UBTC",
+  usdt: "USDT0",
+  usdt0: "USDT0",
+  usdc: "USDC",
+  hype: "HYPE",
+  usdh: "USDH"
+};
+function hyperliquidCanonicalLendCoin(coin) {
+  const trimmed = coin.trim();
+  if (!trimmed) return trimmed;
+  const aliased = HYPERLIQUID_LEND_TOKEN_ALIASES[trimmed.toLowerCase()];
+  return aliased ?? trimmed;
+}
 async function hyperliquidResolvePerpAsset(args) {
   const resolved = await hyperliquidResolvePerpMarket(args);
   return { asset: resolved.asset, szDecimals: resolved.szDecimals, maxLeverage: resolved.maxLeverage };
@@ -657,6 +715,21 @@ async function hyperliquidResolveAsset(args) {
 function hyperliquidIsSpotAssetId(asset) {
   return asset >= HYPERLIQUID_SPOT_ASSET_OFFSET;
 }
+async function hyperliquidResolveSpotToken(args) {
+  const raw = args.coin.trim();
+  if (!raw) throw new Error("Hyperliquid lend token is required.");
+  const asIndex = Number.parseInt(raw, 10);
+  const { tokens } = await hyperliquidFetchSpotTokens({ chainId: args.chainId });
+  if (/^\d+$/.test(raw) && Number.isFinite(asIndex)) {
+    const hit2 = tokens.find((t) => t.tokenIndex === asIndex);
+    if (!hit2) throw new Error(`Unknown Hyperliquid spot token index: ${raw}`);
+    return { tokenIndex: hit2.tokenIndex, coin: hit2.name, szDecimals: hit2.szDecimals };
+  }
+  const canonical = hyperliquidCanonicalLendCoin(raw);
+  const hit = tokens.find((t) => t.name.toLowerCase() === canonical.toLowerCase());
+  if (!hit) throw new Error(`Unknown Hyperliquid spot token: ${raw}`);
+  return { tokenIndex: hit.tokenIndex, coin: hit.name, szDecimals: hit.szDecimals };
+}
 
 // src/protocols/evm/hyperliquid/reads.ts
 function hyperliquidUsdAmountString(value) {
@@ -868,6 +941,149 @@ async function hyperliquidFetchOhlcvSummary(args) {
   });
   return { ohlcv, resolvedCoin: resolved.name, dex: resolved.dex ?? null };
 }
+
+// src/protocols/evm/hyperliquid/lendReads.ts
+function yearlyRateToAprPercent(raw) {
+  const n = Number.parseFloat(String(raw ?? "").trim());
+  if (!Number.isFinite(n)) return null;
+  return n * 100;
+}
+function decimalGtZero(raw) {
+  const n = Number.parseFloat(String(raw ?? "").trim());
+  return Number.isFinite(n) && n > 0;
+}
+function hyperliquidLendRoleFromLtv(ltv) {
+  return decimalGtZero(ltv) ? "collateral" : "quote";
+}
+function parseHyperliquidBorrowLendReserveTuples(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (const entry of raw) {
+    if (!Array.isArray(entry) || entry.length < 2) continue;
+    const tokenIndex = Number(entry[0]);
+    const state = entry[1];
+    if (!Number.isFinite(tokenIndex) || !state || typeof state !== "object") continue;
+    out.push([
+      tokenIndex,
+      {
+        borrowYearlyRate: String(state.borrowYearlyRate ?? "0"),
+        supplyYearlyRate: String(state.supplyYearlyRate ?? "0"),
+        balance: String(state.balance ?? "0"),
+        utilization: String(state.utilization ?? "0"),
+        oraclePx: String(state.oraclePx ?? "0"),
+        ltv: String(state.ltv ?? "0"),
+        totalSupplied: String(state.totalSupplied ?? "0"),
+        totalBorrowed: String(state.totalBorrowed ?? "0")
+      }
+    ]);
+  }
+  return out;
+}
+function parseHyperliquidBorrowLendUserState(raw) {
+  const o = raw && typeof raw === "object" ? raw : {};
+  const tokenToState = [];
+  const rows = Array.isArray(o.tokenToState) ? o.tokenToState : [];
+  for (const entry of rows) {
+    if (!Array.isArray(entry) || entry.length < 2) continue;
+    const tokenIndex = Number(entry[0]);
+    const state = entry[1];
+    if (!Number.isFinite(tokenIndex) || !state || typeof state !== "object") continue;
+    tokenToState.push([
+      tokenIndex,
+      {
+        borrow: {
+          basis: String(state.borrow?.basis ?? "0.0"),
+          value: String(state.borrow?.value ?? "0.0")
+        },
+        supply: {
+          basis: String(state.supply?.basis ?? "0.0"),
+          value: String(state.supply?.value ?? "0.0")
+        }
+      }
+    ]);
+  }
+  return {
+    tokenToState,
+    health: String(o.health ?? "healthy"),
+    healthFactor: o.healthFactor == null ? null : String(o.healthFactor)
+  };
+}
+function mapHyperliquidLendMarketRows(args) {
+  const tokenByIndex = new Map(args.tokens.map((t) => [t.tokenIndex, t]));
+  return args.reserves.map(([tokenIndex, state]) => {
+    const token = tokenByIndex.get(tokenIndex);
+    const role = hyperliquidLendRoleFromLtv(state.ltv);
+    return {
+      tokenIndex,
+      coin: token?.name ?? `token:${tokenIndex}`,
+      role,
+      szDecimals: token?.szDecimals ?? null,
+      supplyYearlyRate: state.supplyYearlyRate,
+      borrowYearlyRate: state.borrowYearlyRate,
+      supplyAprPercent: yearlyRateToAprPercent(state.supplyYearlyRate),
+      borrowAprPercent: yearlyRateToAprPercent(state.borrowYearlyRate),
+      utilization: state.utilization,
+      oraclePx: state.oraclePx,
+      ltv: state.ltv,
+      totalSupplied: state.totalSupplied,
+      totalBorrowed: state.totalBorrowed,
+      balance: state.balance
+    };
+  });
+}
+function hyperliquidManualBorrowEnabled(abstraction) {
+  return abstraction.trim() !== "portfolioMargin";
+}
+async function hyperliquidFetchLendMarketsSummary(args) {
+  const [{ reserves }, { tokens }] = await Promise.all([
+    hyperliquidFetchAllBorrowLendReserveStates({ chainId: args.chainId }),
+    hyperliquidFetchSpotTokens({ chainId: args.chainId })
+  ]);
+  const markets = mapHyperliquidLendMarketRows({
+    reserves: parseHyperliquidBorrowLendReserveTuples(reserves),
+    tokens
+  });
+  return {
+    markets,
+    notes: "Hyperliquid Core lend yearly rates are APR (supplyYearlyRate / borrowYearlyRate), not APY. Collateral (HYPE, UBTC) does not earn supply interest. Quote supply (USDC, USDT0, USDH) earns utilization APR but does not increase borrow capacity. Rates update hourly."
+  };
+}
+async function hyperliquidFetchLendPositionsSummary(args) {
+  const user = args.executorAddress.trim().toLowerCase();
+  const [{ state }, { abstraction }, { tokens }, { reserves }] = await Promise.all([
+    hyperliquidFetchBorrowLendUserState({ chainId: args.chainId, user }),
+    hyperliquidFetchUserAbstraction({ chainId: args.chainId, user }),
+    hyperliquidFetchSpotTokens({ chainId: args.chainId }),
+    hyperliquidFetchAllBorrowLendReserveStates({ chainId: args.chainId })
+  ]);
+  const parsed = parseHyperliquidBorrowLendUserState(state);
+  const tokenByIndex = new Map(tokens.map((t) => [t.tokenIndex, t]));
+  const roleByIndex = new Map(
+    parseHyperliquidBorrowLendReserveTuples(reserves).map(([idx, s]) => [idx, hyperliquidLendRoleFromLtv(s.ltv)])
+  );
+  const positions = parsed.tokenToState.filter(([, s]) => decimalGtZero(s.supply.value) || decimalGtZero(s.borrow.value)).map(([tokenIndex, s]) => ({
+    tokenIndex,
+    coin: tokenByIndex.get(tokenIndex)?.name ?? `token:${tokenIndex}`,
+    role: roleByIndex.get(tokenIndex) ?? null,
+    suppliedBasis: s.supply.basis,
+    suppliedValue: s.supply.value,
+    borrowedBasis: s.borrow.basis,
+    borrowedValue: s.borrow.value
+  }));
+  const manualBorrowEnabled = hyperliquidManualBorrowEnabled(abstraction);
+  const summary = {
+    positions,
+    health: parsed.health,
+    healthFactor: parsed.healthFactor,
+    userAbstraction: abstraction,
+    manualBorrowEnabled,
+    notes: manualBorrowEnabled ? "Manual borrow is available on this account. Portfolio-margin accounts use automated borrow instead." : "Portfolio-margin account: borrowing is automated and the manual borrow action is disabled. Supply/withdraw/repay may still apply."
+  };
+  return summary;
+}
+async function hyperliquidResolveLendTokenForChain(args) {
+  return hyperliquidResolveSpotToken({ chainId: args.chainId, coin: args.coin });
+}
 var coreWriterAbi = viem.parseAbi(["function sendRawAction(bytes data) external"]);
 var ACTION_LIMIT_ORDER = 1;
 var ACTION_VAULT_TRANSFER = 2;
@@ -1380,6 +1596,28 @@ function buildHyperliquidUpdateLeverageAction(args) {
     leverage
   };
 }
+function parseHyperliquidBorrowLendAmount(amountHuman) {
+  if (amountHuman == null) return null;
+  const trimmed = String(amountHuman).trim();
+  if (!trimmed || trimmed.toLowerCase() === "max") return null;
+  return hyperliquidFloatToWire(trimmed);
+}
+function buildHyperliquidBorrowLendAction(args) {
+  const operation = args.operation;
+  if (operation !== "supply" && operation !== "withdraw" && operation !== "repay" && operation !== "borrow") {
+    throw new Error("operation must be supply, withdraw, repay, or borrow");
+  }
+  const token = Math.trunc(args.token);
+  if (!Number.isFinite(token) || token < 0) {
+    throw new Error("token must be a non-negative integer token index");
+  }
+  return {
+    type: "borrowLend",
+    operation,
+    token,
+    amount: args.amount
+  };
+}
 function hyperliquidFloatToWire(value) {
   const n = typeof value === "number" ? value : Number.parseFloat(String(value).trim());
   if (!Number.isFinite(n)) throw new Error("Invalid Hyperliquid wire number.");
@@ -1625,6 +1863,57 @@ async function buildHyperliquidUpdateLeverageMultisign(args) {
     ]
   });
 }
+async function buildHyperliquidBorrowLendMultisign(args) {
+  const { tokenIndex, coin } = await hyperliquidResolveSpotToken({
+    chainId: args.chainId,
+    coin: args.coin
+  });
+  const amount = args.amountMax === true ? null : parseHyperliquidBorrowLendAmount(args.amountHuman);
+  if (amount == null && args.operation !== "withdraw" && args.operation !== "repay" && args.amountMax !== true) {
+    throw new Error("amountHuman is required unless amountMax is true (full withdraw/repay).");
+  }
+  const action = buildHyperliquidBorrowLendAction({
+    operation: args.operation,
+    token: tokenIndex,
+    amount
+  });
+  const nonce = args.nonce ?? Date.now();
+  const isTestnet = args.chainId === 998;
+  const typed = buildHyperliquidAgentTypedData({ action, nonce, isTestnet });
+  return buildEip712Multisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: ZERO_ADDRESS,
+    legs: [
+      {
+        typedData: {
+          domain: typed.domain,
+          types: typed.types,
+          primaryType: typed.primaryType,
+          message: typed.message
+        },
+        delivery: {
+          kind: "hyperliquid_exchange",
+          chainId: args.chainId,
+          isTestnet,
+          action,
+          nonce
+        },
+        audit: {
+          protocol: "hyperliquid",
+          action: "borrowLend",
+          operation: args.operation,
+          coin,
+          token: tokenIndex,
+          amount,
+          nonce,
+          connectionId: typed.connectionId
+        }
+      }
+    ]
+  });
+}
 
 // src/protocols/evm/hyperliquid/multisign.ts
 function hasHyperliquidBracketTpsl(args) {
@@ -2217,6 +2506,19 @@ var hyperliquidProtocolModule = {
         marketKind: { type: "string", required: false, description: "perp (default) or spot" }
       }
     },
+    {
+      id: "hyperliquid.lend",
+      protocolId: HYPERLIQUID_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Hyperliquid Core borrow/lend via L1 /exchange EIP-712 (supply, withdraw, borrow, repay). Not CoreWriter.",
+      commonParams: ["keyGen", "purposeText"],
+      params: {
+        coin: { type: "string", required: true, description: "Spot token e.g. USDC, USDT, HYPE, BTC/UBTC" },
+        operation: { type: "string", required: true, description: "supply | withdraw | borrow | repay" },
+        amountHuman: { type: "string", required: false, description: "Amount; omit or max for full withdraw/repay" },
+        amountMax: { type: "boolean", required: false, description: "true = full amount (amount null on wire)" }
+      }
+    },
     {
       id: "hyperliquid.undelegate",
       protocolId: HYPERLIQUID_PROTOCOL_ID,
@@ -2276,6 +2578,8 @@ exports.buildEvmMultisignBodyHyperliquidUsdClassTransferBatch = buildEvmMultisig
 exports.buildEvmMultisignBodyHyperliquidVaultDepositBatch = buildEvmMultisignBodyHyperliquidVaultDepositBatch;
 exports.buildEvmMultisignBodyHyperliquidVaultWithdrawBatch = buildEvmMultisignBodyHyperliquidVaultWithdrawBatch;
 exports.buildHyperliquidAgentTypedData = buildHyperliquidAgentTypedData;
+exports.buildHyperliquidBorrowLendAction = buildHyperliquidBorrowLendAction;
+exports.buildHyperliquidBorrowLendMultisign = buildHyperliquidBorrowLendMultisign;
 exports.buildHyperliquidBridgeWithdrawMultisign = buildHyperliquidBridgeWithdrawMultisign;
 exports.buildHyperliquidLimitOrderWire = buildHyperliquidLimitOrderWire;
 exports.buildHyperliquidLimitOrderWithTpslMultisign = buildHyperliquidLimitOrderWithTpslMultisign;
@@ -2291,6 +2595,7 @@ exports.createHyperliquidL1ActionHash = createHyperliquidL1ActionHash;
 exports.hyperliquidApiBaseUrl = hyperliquidApiBaseUrl;
 exports.hyperliquidBridgeArbitrumChainId = hyperliquidBridgeArbitrumChainId;
 exports.hyperliquidBridgeConfig = hyperliquidBridgeConfig;
+exports.hyperliquidCanonicalLendCoin = hyperliquidCanonicalLendCoin;
 exports.hyperliquidCollectAllPerpMarkets = hyperliquidCollectAllPerpMarkets;
 exports.hyperliquidCollectHip3StockMarkets = hyperliquidCollectHip3StockMarkets;
 exports.hyperliquidCollectNativePerpMarkets = hyperliquidCollectNativePerpMarkets;
@@ -2298,13 +2603,18 @@ exports.hyperliquidEncodePx8 = hyperliquidEncodePx8;
 exports.hyperliquidEncodeUsd6 = hyperliquidEncodeUsd6;
 exports.hyperliquidEncodeWei8 = hyperliquidEncodeWei8;
 exports.hyperliquidFetchActiveAssetData = hyperliquidFetchActiveAssetData;
+exports.hyperliquidFetchAllBorrowLendReserveStates = hyperliquidFetchAllBorrowLendReserveStates;
 exports.hyperliquidFetchAllMids = hyperliquidFetchAllMids;
+exports.hyperliquidFetchBorrowLendReserveState = hyperliquidFetchBorrowLendReserveState;
+exports.hyperliquidFetchBorrowLendUserState = hyperliquidFetchBorrowLendUserState;
 exports.hyperliquidFetchCandles = hyperliquidFetchCandles;
 exports.hyperliquidFetchClearinghouseState = hyperliquidFetchClearinghouseState;
 exports.hyperliquidFetchDelegations = hyperliquidFetchDelegations;
 exports.hyperliquidFetchDelegationsForExecutor = hyperliquidFetchDelegationsForExecutor;
 exports.hyperliquidFetchDexList = hyperliquidFetchDexList;
 exports.hyperliquidFetchFrontendOpenOrders = hyperliquidFetchFrontendOpenOrders;
+exports.hyperliquidFetchLendMarketsSummary = hyperliquidFetchLendMarketsSummary;
+exports.hyperliquidFetchLendPositionsSummary = hyperliquidFetchLendPositionsSummary;
 exports.hyperliquidFetchMarketSnapshot = hyperliquidFetchMarketSnapshot;
 exports.hyperliquidFetchMarketSnapshotSummary = hyperliquidFetchMarketSnapshotSummary;
 exports.hyperliquidFetchMarketsSummary = hyperliquidFetchMarketsSummary;
@@ -2322,11 +2632,13 @@ exports.hyperliquidFetchPositionDisplayRows = hyperliquidFetchPositionDisplayRow
 exports.hyperliquidFetchPositionsForExecutor = hyperliquidFetchPositionsForExecutor;
 exports.hyperliquidFetchSpotClearinghouseState = hyperliquidFetchSpotClearinghouseState;
 exports.hyperliquidFetchSpotMeta = hyperliquidFetchSpotMeta;
+exports.hyperliquidFetchSpotTokens = hyperliquidFetchSpotTokens;
 exports.hyperliquidFetchStakingSummary = hyperliquidFetchStakingSummary;
 exports.hyperliquidFetchStakingSummaryForExecutor = hyperliquidFetchStakingSummaryForExecutor;
 exports.hyperliquidFetchStockMarketsSummary = hyperliquidFetchStockMarketsSummary;
 exports.hyperliquidFetchUsdClassBalances = hyperliquidFetchUsdClassBalances;
 exports.hyperliquidFetchUsdClassBalancesSummary = hyperliquidFetchUsdClassBalancesSummary;
+exports.hyperliquidFetchUserAbstraction = hyperliquidFetchUserAbstraction;
 exports.hyperliquidFetchUserVaultEquities = hyperliquidFetchUserVaultEquities;
 exports.hyperliquidFetchUserVaultEquitiesSummary = hyperliquidFetchUserVaultEquitiesSummary;
 exports.hyperliquidFetchVaultApysSummary = hyperliquidFetchVaultApysSummary;
@@ -2336,6 +2648,8 @@ exports.hyperliquidFloatToWire = hyperliquidFloatToWire;
 exports.hyperliquidInferDexFromCoin = hyperliquidInferDexFromCoin;
 exports.hyperliquidIsSpotAssetId = hyperliquidIsSpotAssetId;
 exports.hyperliquidL1TifFromKey = hyperliquidL1TifFromKey;
+exports.hyperliquidLendRoleFromLtv = hyperliquidLendRoleFromLtv;
+exports.hyperliquidManualBorrowEnabled = hyperliquidManualBorrowEnabled;
 exports.hyperliquidMarketSymbol = hyperliquidMarketSymbol;
 exports.hyperliquidOrderClosesPosition = hyperliquidOrderClosesPosition;
 exports.hyperliquidOrderCountsAsPendingClose = hyperliquidOrderCountsAsPendingClose;
@@ -2343,10 +2657,12 @@ exports.hyperliquidPendingCloseByCoin = hyperliquidPendingCloseByCoin;
 exports.hyperliquidPendingCloseForPosition = hyperliquidPendingCloseForPosition;
 exports.hyperliquidProtocolModule = hyperliquidProtocolModule;
 exports.hyperliquidResolveAsset = hyperliquidResolveAsset;
+exports.hyperliquidResolveLendTokenForChain = hyperliquidResolveLendTokenForChain;
 exports.hyperliquidResolveOhlcvWindow = hyperliquidResolveOhlcvWindow;
 exports.hyperliquidResolvePerpAsset = hyperliquidResolvePerpAsset;
 exports.hyperliquidResolvePerpMarket = hyperliquidResolvePerpMarket;
 exports.hyperliquidResolveSpotAsset = hyperliquidResolveSpotAsset;
+exports.hyperliquidResolveSpotToken = hyperliquidResolveSpotToken;
 exports.hyperliquidResolveTif = hyperliquidResolveTif;
 exports.hyperliquidSearchMarkets = hyperliquidSearchMarkets;
 exports.hyperliquidSearchMarketsSummary = hyperliquidSearchMarketsSummary;
@@ -2355,6 +2671,10 @@ exports.isHyperliquidBridgeArbitrumChainSupported = isHyperliquidBridgeArbitrumC
 exports.isHyperliquidBridgeArbitrumUsdcRow = isHyperliquidBridgeArbitrumUsdcRow;
 exports.isHyperliquidChainSupported = isHyperliquidChainSupported;
 exports.isHyperliquidHyperEvmUsdcRow = isHyperliquidHyperEvmUsdcRow;
+exports.mapHyperliquidLendMarketRows = mapHyperliquidLendMarketRows;
+exports.parseHyperliquidBorrowLendAmount = parseHyperliquidBorrowLendAmount;
+exports.parseHyperliquidBorrowLendReserveTuples = parseHyperliquidBorrowLendReserveTuples;
+exports.parseHyperliquidBorrowLendUserState = parseHyperliquidBorrowLendUserState;
 exports.validateHyperliquidTpslGeometry = validateHyperliquidTpslGeometry;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map