@continuumdao/ctm-mpc-defi 0.2.50 → 0.2.52

package/dist/protocols/evm/trueo/index.js

@@ -1102,6 +1102,506 @@ function suggestTrueoTokensToAdd(args) {
   }
 }
 
+// src/protocols/evm/hyperliquid/support.ts
+var HYPERLIQUID_SUPPORTED_CHAIN_IDS = [999, 998];
+function isHyperliquidChainSupported(chainId) {
+  return HYPERLIQUID_SUPPORTED_CHAIN_IDS.includes(chainId);
+}
+function hyperliquidApiBaseUrl(chainId) {
+  return chainId === 998 ? "https://api.hyperliquid-testnet.xyz" : "https://api.hyperliquid.xyz";
+}
+
+// src/protocols/evm/hyperliquidOutcome/model.ts
+function outcomeEncoding(outcome, side) {
+  const o = Math.trunc(outcome);
+  const s = Math.trunc(side);
+  if (!Number.isFinite(o) || o < 0) throw new Error("outcome must be a non-negative integer");
+  if (s !== 0 && s !== 1) throw new Error("side must be 0 or 1");
+  return 10 * o + s;
+}
+function outcomeTradeCoin(encoding) {
+  return `#${encoding}`;
+}
+function outcomeBalanceCoin(encoding) {
+  return `+${encoding}`;
+}
+function outcomeAssetId(encoding) {
+  return 1e8 + encoding;
+}
+function outcomeSideName(name, fallback) {
+  const raw = (name ?? "").trim();
+  const stripped = raw.replace(/^template:/i, "").trim();
+  return stripped || fallback;
+}
+function parseHyperliquidPipeFields(description) {
+  const out = {};
+  for (const part of (description ?? "").split("|")) {
+    const i = part.indexOf(":");
+    if (i <= 0) continue;
+    const key = part.slice(0, i).trim();
+    const value = part.slice(i + 1).trim();
+    if (key && value) out[key] = value;
+  }
+  return out;
+}
+function parseHyperliquidStamp(raw) {
+  const m = /^(\d{4})(\d{2})(\d{2})-(\d{2})(\d{2})$/.exec((raw ?? "").trim());
+  if (!m) return null;
+  const ms = Date.parse(`${m[1]}-${m[2]}-${m[3]}T${m[4]}:${m[5]}:00Z`);
+  return Number.isFinite(ms) ? Math.floor(ms / 1e3) : null;
+}
+function formatHyperliquidStamp(unixSec) {
+  if (unixSec == null || !Number.isFinite(unixSec) || unixSec <= 0) return null;
+  const d = new Date(unixSec * 1e3);
+  if (Number.isNaN(d.getTime())) return null;
+  const pad = (n) => String(n).padStart(2, "0");
+  return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())} ${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())} UTC`;
+}
+function questionForOutcome(outcomeId, questions) {
+  for (const q of questions) {
+    if (q.fallbackOutcome === outcomeId) return q;
+    if ((q.namedOutcomes ?? []).includes(outcomeId)) return q;
+  }
+  return void 0;
+}
+function formatOutcomeQuestion(outcome, question) {
+  const fields = parseHyperliquidPipeFields(outcome.description);
+  const qFields = parseHyperliquidPipeFields(question?.description);
+  const when = formatHyperliquidStamp(
+    parseHyperliquidStamp(fields.time) ?? parseHyperliquidStamp(qFields.resolutionDeadline)
+  );
+  const whenSuffix = when ? ` at ${when}` : "";
+  if (outcome.name === "template:binaryPrice") {
+    const asset = fields.priceDescription || fields.perp || "the asset";
+    const threshold = fields.threshold ?? "";
+    return `Will ${asset} be above ${threshold}${whenSuffix}?`.replace(/\s+/g, " ").trim();
+  }
+  if (outcome.name === "template:priceTouch") {
+    const asset = fields.priceDescription || fields.perp || "the asset";
+    const target = fields.target ?? "";
+    return `Will ${asset} touch ${target}${when ? ` by ${when}` : ""}?`.replace(/\s+/g, " ").trim();
+  }
+  if (outcome.name === "template:sportsTournamentParticipant") {
+    const participant = fields.participant || "this participant";
+    const competition = qFields.competition;
+    return competition ? `Will ${participant} win ${competition}?` : `Will ${participant} win?`;
+  }
+  const desc = (outcome.description ?? "").trim();
+  if (desc && desc !== "other") return desc;
+  return outcome.name || `Outcome ${outcome.outcome}`;
+}
+var STAMP_FIELDS = /* @__PURE__ */ new Set([
+  "time",
+  "dateTime",
+  "resolutionDeadline",
+  "scheduledStart",
+  "scheduledDecision",
+  "expiry",
+  "decisionDeadline"
+]);
+function outcomeTemplateId(name) {
+  return (name ?? "").replace(/^template:/, "").trim();
+}
+function outcomeFieldMap(outcome, question) {
+  return {
+    ...parseHyperliquidPipeFields(question?.description),
+    ...parseHyperliquidPipeFields(outcome.description)
+  };
+}
+function displayField(key, raw) {
+  if (STAMP_FIELDS.has(key)) {
+    const formatted = formatHyperliquidStamp(parseHyperliquidStamp(raw));
+    if (formatted) return formatted;
+  }
+  return raw.trim();
+}
+function fillOutcomeTemplate(text, fields) {
+  return text.replace(/\{([A-Za-z0-9_]+)\}/g, (token, key) => {
+    const raw = fields[key];
+    if (raw == null || !raw.trim()) return token;
+    return displayField(key, raw);
+  });
+}
+function stripTemplateMetadata(text) {
+  return (text.split(/\smetadata=/)[0] ?? text).replace(/\bprice price\b/g, "price").trim();
+}
+function templateById(templates, id) {
+  return templates?.find((template) => template.id === id);
+}
+function parentTemplateId(template) {
+  const role = template?.role;
+  if (!role || typeof role !== "object") return null;
+  const parent = role.questionOutcome?.parent?.trim();
+  return parent || null;
+}
+function resolveOutcomeSideLabel(specName, fields, fallback) {
+  const raw = outcomeSideName(specName, fallback);
+  const filled = fillOutcomeTemplate(raw, fields).trim();
+  return filled || fallback;
+}
+function recurringRules(outcome, fields) {
+  const when = fields.expiry ? displayField("expiry", fields.expiry) : "expiry";
+  const asset = fields.underlying || "the asset";
+  if (outcome.name === "Recurring" && fields.class === "priceBinary") {
+    const period = fields.period ? ` Period ${fields.period}.` : "";
+    return `Yes if the ${asset} HyperCore mark at ${when} is at or above ${fields.targetPrice ?? "\u2014"}. Otherwise No. The mark is the linear interpolation of the HyperCore mark updates immediately before and after that time.${period}`;
+  }
+  if (outcome.name === "Recurring Fallback") {
+    return `Yes if none of the named ${asset} price buckets contain the mark at ${when}. Otherwise No. Thresholds: ${fields.priceThresholds || "\u2014"}.`;
+  }
+  if (outcome.name === "Recurring Named Outcome") {
+    return `Yes if bucket ${fields.index ?? "\u2014"} is the ${asset} price range that contains the interpolated HyperCore mark at ${when}. Otherwise No. Thresholds: ${fields.priceThresholds || "\u2014"}.`;
+  }
+  return null;
+}
+function fallbackRules(outcome, fields) {
+  const id = outcomeTemplateId(outcome.name);
+  const when = fields.time ? displayField("time", fields.time) : "the settlement time";
+  const feed = fields.priceDescription || fields.perp || "the price";
+  if (id === "binaryPrice") {
+    const twap = fields.seconds ? ` Settlement uses the ${fields.seconds}-second TWAP of ${feed} ending at ${when}.` : "";
+    return `Yes if the ${fields.perp || feed} price is above ${fields.threshold ?? "\u2014"} at ${when}. Otherwise No.${twap}`.replace(
+      /\bprice price\b/g,
+      "price"
+    );
+  }
+  if (id === "priceTouch") {
+    return `Yes if the ${fields.perp || feed} price touches ${fields.target ?? "\u2014"} at or before ${when}. Otherwise No. A touch is the ${fields.seconds || "\u2014"}-second TWAP of ${feed} equaling or crossing the target.`;
+  }
+  if (id === "companyIpoConfirmed") {
+    const at = fields.dateTime ? displayField("dateTime", fields.dateTime) : "the deadline";
+    return `Yes if ${fields.company || "the company"}'s first public listing is confirmed at or before ${at}. Otherwise No.`;
+  }
+  if (id === "sportsTournamentParticipant" || id === "sportsContestParticipant2") {
+    return `Yes if ${fields.participant || "this participant"} is the sole winner. Otherwise No.`;
+  }
+  if (id === "sportsContestDraw2") return "Yes if the contest is a draw. Otherwise No.";
+  if (id === "policyRateNoChange") return "Yes if the announced policy value equals the prior value. Otherwise No.";
+  if (id === "policyRateDecrease") return "Yes if the announced policy value is lower than the prior value. Otherwise No.";
+  if (id === "policyRateIncrease") return "Yes if the announced policy value is higher than the prior value. Otherwise No.";
+  if (id === "sportsContestWinner") {
+    const a = fields.shortNameA || fields.participantA || "Side A";
+    const b = fields.shortNameB || fields.participantB || "Side B";
+    return `${a} wins if ${fields.participantA || a} wins the contest. ${b} wins if ${fields.participantB || b} wins. Counted play: ${fields.countedPlay || "the scheduled contest"}.`;
+  }
+  return "";
+}
+function formatOutcomeRules(outcome, question, templates) {
+  const fields = outcomeFieldMap(outcome, question);
+  const recurring = recurringRules(outcome, fields);
+  if (recurring) return recurring;
+  const template = templateById(templates, outcomeTemplateId(outcome.name));
+  const ownRaw = template?.description?.trim();
+  const own = ownRaw ? stripTemplateMetadata(fillOutcomeTemplate(ownRaw, fields)) : fallbackRules(outcome, fields);
+  const parentRaw = templateById(templates, parentTemplateId(template) ?? "")?.description?.trim();
+  const parent = parentRaw ? stripTemplateMetadata(fillOutcomeTemplate(parentRaw, fields)) : "";
+  if (own && parent) return `${own}
+
+${parent}`;
+  return own;
+}
+function outcomeExpiryUnix(outcome, question) {
+  const fields = parseHyperliquidPipeFields(outcome.description);
+  const qFields = parseHyperliquidPipeFields(question?.description);
+  return parseHyperliquidStamp(fields.time) ?? parseHyperliquidStamp(qFields.resolutionDeadline) ?? 0;
+}
+
+// src/protocols/evm/hyperliquidOutcome/api.ts
+var HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID = 999;
+var META_TTL_MS = 15e3;
+var metaCache = /* @__PURE__ */ new Map();
+function outcomeFetchFailure(error) {
+  if (!(error instanceof Error)) return "request failed";
+  const cause = error.cause;
+  if (cause instanceof Error && cause.message.trim()) return cause.message;
+  return error.message;
+}
+function outcomeErrorCode(error) {
+  if (!error || typeof error !== "object") return "";
+  if ("code" in error && error.code != null) return String(error.code);
+  if (error instanceof Error && error.cause && typeof error.cause === "object" && "code" in error.cause) {
+    return String(error.cause.code ?? "");
+  }
+  return "";
+}
+var OUTCOME_RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "UND_ERR_CONNECT_TIMEOUT",
+  "UND_ERR_CONNECT",
+  "ECONNRESET",
+  "ECONNREFUSED",
+  "ETIMEDOUT",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "EPIPE"
+]);
+function outcomeFetchRetryable(error) {
+  if (error && typeof error === "object" && "outcomeFinal" in error) return false;
+  const code = outcomeErrorCode(error);
+  return OUTCOME_RETRYABLE_CODES.has(code) || error instanceof Error && (error.message === "fetch failed" || error.message === "connect timeout");
+}
+var outcomeHttpsAgent = null;
+async function outcomeNodeModules() {
+  const importer = new Function("specifier", "return import(specifier)");
+  const [http2, https] = await Promise.all([importer("node:http"), importer("node:https")]);
+  return { http: http2, https };
+}
+async function outcomeNodePost(urlString, payload) {
+  const { http: http2, https } = await outcomeNodeModules();
+  if (!outcomeHttpsAgent) {
+    outcomeHttpsAgent = new https.Agent({ keepAlive: true, maxSockets: 4, timeout: 2e4 });
+  }
+  const url = new URL(urlString);
+  const lib = url.protocol === "http:" ? http2 : https;
+  return new Promise((resolve, reject) => {
+    const req = lib.request(
+      {
+        protocol: url.protocol,
+        hostname: url.hostname,
+        port: url.port || void 0,
+        path: `${url.pathname}${url.search}`,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(payload)
+        },
+        agent: url.protocol === "https:" ? outcomeHttpsAgent ?? void 0 : void 0,
+        timeout: 2e4
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          resolve({ status: res.statusCode ?? 0, text: Buffer.concat(chunks).toString("utf8") });
+        });
+      }
+    );
+    req.on("timeout", () => {
+      const error = new Error("connect timeout");
+      error.code = "ETIMEDOUT";
+      req.destroy(error);
+    });
+    req.on("error", reject);
+    req.write(payload);
+    req.end();
+  });
+}
+async function outcomeFetchPost(url, payload) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: payload,
+    cache: "no-store"
+  });
+  return { status: res.status, text: await res.text() };
+}
+async function outcomeInfoPost(chainId, body) {
+  if (!isHyperliquidChainSupported(chainId)) {
+    throw new Error(`Hyperliquid outcome markets require chainId 999 or 998 (got ${chainId}).`);
+  }
+  const url = `${hyperliquidApiBaseUrl(chainId)}/info`;
+  const payload = JSON.stringify(body);
+  let last;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const res = typeof window !== "undefined" || process.env.VITEST ? await outcomeFetchPost(url, payload) : await outcomeNodePost(url, payload);
+      if (res.status < 200 || res.status >= 300) {
+        const error = new Error(`Hyperliquid info API failed (${res.status}): ${res.text.slice(0, 200)}`);
+        if (res.status !== 429 && res.status !== 502 && res.status !== 503 && res.status !== 504) {
+          error.outcomeFinal = true;
+        }
+        throw error;
+      }
+      return JSON.parse(res.text);
+    } catch (error) {
+      last = error;
+      if (!outcomeFetchRetryable(error) || attempt === 2) break;
+      await new Promise((resolve) => setTimeout(resolve, 250 * (attempt + 1)));
+    }
+  }
+  throw new Error(`Hyperliquid info API failed: ${outcomeFetchFailure(last)}`);
+}
+function priceNumber(raw) {
+  if (raw == null || raw === "") return null;
+  const n = Number.parseFloat(raw);
+  return Number.isFinite(n) ? n : null;
+}
+function priceLabel(n) {
+  if (n == null) return null;
+  if (n >= 0 && n <= 1) return `${(n * 100).toFixed(1)}%`;
+  return String(n);
+}
+function marketFromMeta(outcome, question, mids, nowSec, templates) {
+  const fields = outcomeFieldMap(outcome, question);
+  const yesEncoding = outcomeEncoding(outcome.outcome, 0);
+  const noEncoding = outcomeEncoding(outcome.outcome, 1);
+  const yesCoin = outcomeTradeCoin(yesEncoding);
+  const noCoin = outcomeTradeCoin(noEncoding);
+  const yesPrice = priceNumber(mids[yesCoin]);
+  const noPrice = priceNumber(mids[noCoin]);
+  const endOfTrading = outcomeExpiryUnix(outcome, question);
+  const closed = endOfTrading > 0 && nowSec >= endOfTrading;
+  const template = outcome.name.replace(/^template:/, "");
+  const categories = [template, outcome.venue].filter((v) => Boolean(v && v.trim()));
+  return {
+    outcome: outcome.outcome,
+    name: outcome.name,
+    description: outcome.description,
+    question: formatOutcomeQuestion(outcome, question),
+    questionId: question?.question ?? null,
+    sideNames: [
+      resolveOutcomeSideLabel(outcome.sideSpecs?.[0]?.name, fields, "Yes"),
+      resolveOutcomeSideLabel(outcome.sideSpecs?.[1]?.name, fields, "No")
+    ],
+    quoteToken: outcome.quoteToken?.trim() || "USDC",
+    venue: outcome.venue ?? "",
+    categories,
+    yesEncoding,
+    noEncoding,
+    yesCoin,
+    noCoin,
+    yesAssetId: outcomeAssetId(yesEncoding),
+    noAssetId: outcomeAssetId(noEncoding),
+    yesBalanceCoin: outcomeBalanceCoin(yesEncoding),
+    noBalanceCoin: outcomeBalanceCoin(noEncoding),
+    yesPrice,
+    noPrice,
+    yesPriceLabel: priceLabel(yesPrice),
+    noPriceLabel: priceLabel(noPrice),
+    expiresAt: formatHyperliquidStamp(endOfTrading > 0 ? endOfTrading : null),
+    endOfTrading,
+    status: closed ? "closed" : "live",
+    tradable: !closed,
+    rules: formatOutcomeRules(outcome, question, templates)
+  };
+}
+async function loadOutcomeSnapshot(chainId) {
+  const hit = metaCache.get(chainId);
+  if (hit && Date.now() - hit.at < META_TTL_MS) {
+    return {
+      outcomes: hit.data.outcomes ?? [],
+      questions: hit.data.questions ?? [],
+      mids: hit.mids,
+      templates: hit.templates
+    };
+  }
+  const meta = await outcomeInfoPost(chainId, { type: "outcomeMeta" });
+  let mids = {};
+  try {
+    mids = await outcomeInfoPost(chainId, { type: "allMids" });
+  } catch {
+    mids = {};
+  }
+  let templates = [];
+  try {
+    const raw = await outcomeInfoPost(chainId, { type: "outcomeTemplates" });
+    templates = Array.isArray(raw) ? raw : [];
+  } catch {
+    templates = [];
+  }
+  metaCache.set(chainId, { at: Date.now(), data: meta, mids, templates });
+  return { outcomes: meta.outcomes ?? [], questions: meta.questions ?? [], mids, templates };
+}
+function hyperliquidOutcomeMatchesQuery(market, query) {
+  const q = query.trim().toLowerCase();
+  if (!q) return true;
+  const hay = [market.question, market.description, market.name, market.sideNames.join(" "), String(market.outcome)].join(" ").toLowerCase();
+  return hay.includes(q);
+}
+async function listHyperliquidOutcomeMarkets(args) {
+  const chainId = args.chainId ?? HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID;
+  const snap = await loadOutcomeSnapshot(chainId);
+  const nowSec = Math.floor(Date.now() / 1e3);
+  const markets = snap.outcomes.map(
+    (outcome) => marketFromMeta(
+      outcome,
+      questionForOutcome(outcome.outcome, snap.questions),
+      snap.mids,
+      nowSec,
+      snap.templates
+    )
+  ).filter((market) => hyperliquidOutcomeMatchesQuery(market, args.query ?? ""));
+  return { markets, questions: snap.questions };
+}
+async function getHyperliquidOutcomeMarket(args) {
+  const { markets } = await listHyperliquidOutcomeMarkets({ chainId: args.chainId });
+  const found = markets.find((m) => m.outcome === args.outcomeId);
+  if (!found) throw new Error(`Hyperliquid outcome ${args.outcomeId} is not in outcomeMeta.`);
+  return found;
+}
+function normalizeLevels(rows) {
+  return (rows ?? []).map((row) => ({
+    px: String(row.px ?? ""),
+    sz: String(row.sz ?? ""),
+    n: Number(row.n ?? 0)
+  }));
+}
+var CHANCE_LOOKBACK_MS = 14 * 24 * 60 * 60 * 1e3;
+async function fetchHyperliquidOutcomeChanceSeries(args) {
+  const chainId = args.chainId ?? HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID;
+  const endTime = Date.now();
+  const raw = await outcomeInfoPost(chainId, {
+    type: "candleSnapshot",
+    req: {
+      coin: args.coin,
+      interval: "1h",
+      startTime: endTime - CHANCE_LOOKBACK_MS,
+      endTime
+    }
+  });
+  if (!Array.isArray(raw)) return [];
+  return raw.map((bar) => {
+    const timestamp = Number(bar.t);
+    const open = Number(bar.o);
+    const high = Number(bar.h);
+    const low = Number(bar.l);
+    const close = Number(bar.c);
+    if (![timestamp, open, high, low, close].every(Number.isFinite)) return null;
+    return { timestamp, open, high, low, close };
+  }).filter((bar) => bar != null);
+}
+async function fetchHyperliquidOutcomeBook(args) {
+  const chainId = args.chainId ?? HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID;
+  const raw = await outcomeInfoPost(chainId, { type: "l2Book", coin: args.coin });
+  if (raw == null || typeof raw !== "object") {
+    return { coin: args.coin, time: null, bids: [], asks: [] };
+  }
+  return {
+    coin: raw.coin ?? args.coin,
+    time: typeof raw.time === "number" ? raw.time : null,
+    bids: normalizeLevels(raw.levels?.[0]),
+    asks: normalizeLevels(raw.levels?.[1])
+  };
+}
+
+// src/protocols/evm/hyperliquidOutcome/mcpSummaries.ts
+function hyperliquidOutcomeToPredictionFields(market, chainId) {
+  return {
+    venue: "hyperliquid",
+    venueMarketId: String(market.outcome),
+    question: market.question,
+    categories: market.categories,
+    yesPrice: market.yesPrice,
+    noPrice: market.noPrice,
+    yesPriceLabel: market.yesPriceLabel,
+    noPriceLabel: market.noPriceLabel,
+    volume: "\u2014",
+    tvl: null,
+    expiresAt: market.expiresAt,
+    expiresAtLabel: market.expiresAt,
+    tradingEndsLabel: market.expiresAt ? `Settles ${market.expiresAt}` : "Settlement time not listed",
+    endOfTrading: market.endOfTrading,
+    status: market.status,
+    outcome: market.outcome,
+    statusUpdatedAt: null,
+    resolutionLabel: null,
+    chainId,
+    paymentSymbol: market.quoteToken,
+    tradable: market.tradable,
+    rules: market.rules,
+    source: market.name
+  };
+}
+
 // src/protocols/evm/trueo/predictionSearch.ts
 var PREDICTION_MARKET_V1_KIND = "continuum/prediction-market/v1";
 function trueoMarketToPredictionRow(row) {
@@ -1134,11 +1634,13 @@ function trueoMarketToPredictionRow(row) {
   };
 }
 async function searchPredictionMarkets(args) {
-  const venues = (args.venues ?? ["trueo"]).map((v) => v.trim().toLowerCase()).filter(Boolean);
-  if (venues.length && !venues.includes("trueo")) {
+  const venues = (args.venues ?? ["trueo", "hyperliquid"]).map((v) => v.trim().toLowerCase()).filter(Boolean);
+  const wantTrueo = venues.includes("trueo");
+  const wantHl = venues.includes("hyperliquid");
+  if (!wantTrueo && !wantHl) {
     return {
       markets: [],
-      notes: "No supported venues in the filter. v1 adapter is trueo (Base).",
+      notes: "No supported venues in the filter. Use trueo and/or hyperliquid.",
       hasMore: false,
       includeAll: false,
       nextOffset: 0,
@@ -1148,6 +1650,33 @@ async function searchPredictionMarkets(args) {
   const includeAll = args.includeAll === true;
   const offset = Math.max(args.offset ?? 0, 0);
   const indexBase = Math.max(args.indexBase ?? 0, 0);
+  const limit = args.limit ?? TRUEO_MARKET_PAGE_SIZE;
+  const exclude = new Set((args.excludeAddresses ?? []).map((id) => id.trim().toLowerCase()).filter(Boolean));
+  let hlAll = [];
+  let hlError = "";
+  if (wantHl) {
+    try {
+      const listed = await listHyperliquidOutcomeMarkets({ query: args.query });
+      hlAll = listed.markets.map((market) => hyperliquidOutcomeToPredictionFields(market, HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID)).filter((row) => !exclude.has(row.venueMarketId.toLowerCase()));
+    } catch (error) {
+      hlError = error instanceof Error ? error.message : "Hyperliquid outcome search failed.";
+    }
+  }
+  if (!wantTrueo) {
+    const page2 = hlAll.slice(offset, offset + limit).map((row, i) => ({ ...row, index: indexBase + i + 1 }));
+    const nextOffset = offset + page2.length;
+    const nextIndexBase2 = indexBase + page2.length;
+    const more2 = nextOffset < hlAll.length;
+    return {
+      markets: page2,
+      hasMore: more2,
+      nextOffset,
+      nextIndexBase: nextIndexBase2,
+      includeAll: false,
+      notes: hlError ? hlError : page2.length ? `Hyperliquid outcome markets. ${more2 ? `More: offset=${nextOffset}, indexBase=${nextIndexBase2}.` : "End of results."} Pick #N then get_prediction_market with venue hyperliquid.` : `No Hyperliquid outcome title match for ${JSON.stringify(args.query?.trim() ?? "")}.`
+    };
+  }
+  const hlPrefix = offset === 0 ? hlAll.slice(0, limit) : [];
   const page = await listTrueoMarketsPage({
     query: args.query,
     category: args.category,
@@ -1156,10 +1685,12 @@ async function searchPredictionMarkets(args) {
     trending: args.trending,
     excludeAddresses: args.excludeAddresses
   });
-  const markets = page.markets.map(trueoMarketToPredictionRow).slice(0, args.limit ?? TRUEO_MARKET_PAGE_SIZE).map((row, i) => ({ ...row, index: indexBase + i + 1 }));
+  const trueoRows = page.markets.map(trueoMarketToPredictionRow).filter((row) => !exclude.has(row.venueMarketId.toLowerCase())).slice(0, limit);
+  const markets = [...hlPrefix, ...trueoRows].map((row, i) => ({ ...row, index: indexBase + i + 1 }));
   const nextIndexBase = indexBase + markets.length;
   const scope = trueoSearchScopeNote(includeAll);
   const q = args.query?.trim() ?? "";
+  const hlNote = hlPrefix.length > 0 ? `Included ${hlPrefix.length} Hyperliquid outcome match(es) on this page (venue hyperliquid).` : hlError;
   if (q && markets.length === 0) {
     return {
       markets,
@@ -1167,17 +1698,17 @@ async function searchPredictionMarkets(args) {
       nextOffset: page.nextOffset,
       nextIndexBase,
       includeAll,
-      notes: `No live or recent title match for ${JSON.stringify(q)} after scanning the catalog. Do not list trending unless the operator asked. ${scope}`
+      notes: `No live or recent title match for ${JSON.stringify(q)} after scanning Trueo${wantHl ? " and Hyperliquid" : ""}. Do not list trending unless the operator asked. ${scope} ${hlError}`.trim()
     };
   }
-  const more = page.hasMore ? `More: search_prediction_markets with offset=${page.nextOffset}, trending=false, indexBase=${nextIndexBase}, excludeAddresses from this page's venueMarketIds.` : "End of results.";
+  const more = page.hasMore ? `More Trueo: search_prediction_markets with offset=${page.nextOffset}, trending=false, indexBase=${nextIndexBase}, excludeAddresses from this page's venueMarketIds.` : "End of Trueo results.";
   return {
     markets,
     hasMore: page.hasMore,
     nextOffset: page.nextOffset,
     nextIndexBase,
     includeAll,
-    notes: `${scope} ${more} Pick #N then get_prediction_market.`
+    notes: `${hlNote} ${scope} ${more} Pick #N then get_prediction_market.`.replace(/\s+/g, " ").trim()
   };
 }
 function buildPredictionMarketEnvelope(market) {
@@ -1242,8 +1773,36 @@ async function listMyPredictionMarketsSummary(input) {
 }
 async function getPredictionMarketSummary(input) {
   const venue = (input.venue ?? "trueo").trim().toLowerCase();
+  if (venue === "hyperliquid") {
+    const outcomeId = Number.parseInt(input.venueMarketId, 10);
+    if (!Number.isFinite(outcomeId)) {
+      throw new Error("Hyperliquid venueMarketId must be the outcome id.");
+    }
+    const market2 = await getHyperliquidOutcomeMarket({ outcomeId });
+    const [yesBook, noBook] = await Promise.all([
+      fetchHyperliquidOutcomeBook({ coin: market2.yesCoin }),
+      fetchHyperliquidOutcomeBook({ coin: market2.noCoin })
+    ]);
+    let ohlc2 = [];
+    try {
+      ohlc2 = await fetchHyperliquidOutcomeChanceSeries({ coin: market2.yesCoin });
+    } catch {
+      ohlc2 = [];
+    }
+    const row2 = {
+      ...hyperliquidOutcomeToPredictionFields(market2, HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID),
+      yesBook,
+      noBook,
+      ohlc: ohlc2
+    };
+    return {
+      kind: PREDICTION_MARKET_V1_KIND,
+      ...row2,
+      envelope: buildPredictionMarketEnvelope(row2)
+    };
+  }
   if (venue !== "trueo") {
-    throw new Error(`Venue "${venue}" is not supported. v1 adapter is trueo.`);
+    throw new Error(`Venue "${venue}" is not supported. Use trueo or hyperliquid.`);
   }
   const row = await fetchTrueoMarket({ marketAddress: input.venueMarketId });
   let ohlc = [];
@@ -1320,7 +1879,8 @@ var DEFI_PROTOCOLS_WITH_30MIN_EXPIRY = /* @__PURE__ */ new Set([
   "aerodrome",
   "pendle",
   "derive",
-  "trueo"
+  "trueo",
+  "hyperliquidOutcome"
 ]);
 function defiMultisignExpiryUnixSeconds(protocolId, explicitExpiryDate) {
   if (typeof explicitExpiryDate === "number" && Number.isFinite(explicitExpiryDate) && explicitExpiryDate > 0) {