@continuumdao/ctm-mpc-defi 0.2.44 → 0.2.46

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