@continuumdao/ctm-mpc-defi 0.2.49 → 0.2.51

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

@@ -0,0 +1,1247 @@
+import { hashTypedData, stringToHex, keccak256 } from 'viem';
+import { getClientIdFromKeyGenResult } from '@continuumdao/continuum-node-sdk';
+import { encode } from '@msgpack/msgpack';
+
+// src/core/registry.ts
+var modules = [];
+function registerProtocolModule(mod) {
+  const existing = modules.findIndex((m) => m.id === mod.id);
+  if (existing >= 0) {
+    modules[existing] = mod;
+  } else {
+    modules.push(mod);
+  }
+}
+
+// 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 outcomeSideIndex(side) {
+  if (side === "no" || side === 1) return 1;
+  return 0;
+}
+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_PROTOCOL_ID = "hyperliquidOutcome";
+var HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID = 999;
+var META_TTL_MS = 15e3;
+var metaCache = /* @__PURE__ */ new Map();
+function clearHyperliquidOutcomeMetaCache() {
+  metaCache.clear();
+}
+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 [http, https] = await Promise.all([importer("node:http"), importer("node:https")]);
+  return { http, https };
+}
+async function outcomeNodePost(urlString, payload) {
+  const { http, 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:" ? http : 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])
+  };
+}
+function outcomeFromBalanceCoin(coin) {
+  if (!coin.startsWith("+")) return null;
+  const encoding = Number.parseInt(coin.slice(1), 10);
+  if (!Number.isFinite(encoding)) return null;
+  const sideDigit = encoding % 10;
+  if (sideDigit !== 0 && sideDigit !== 1) return null;
+  return { outcome: (encoding - sideDigit) / 10, side: sideDigit === 1 ? "no" : "yes" };
+}
+function outcomeFromTradeCoin(coin) {
+  if (!coin.startsWith("#")) return null;
+  return outcomeFromBalanceCoin(`+${coin.slice(1)}`);
+}
+async function fetchHyperliquidOutcomeAccount(args) {
+  const chainId = args.chainId ?? HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID;
+  const user = args.user.trim();
+  if (!user) throw new Error("user address is required");
+  const [spot, orders] = await Promise.all([
+    outcomeInfoPost(chainId, {
+      type: "spotClearinghouseState",
+      user
+    }),
+    outcomeInfoPost(chainId, { type: "openOrders", user })
+  ]);
+  const quoteBalances = [];
+  const outcomeBalances = [];
+  for (const row of spot.balances ?? []) {
+    const coin = String(row.coin ?? "");
+    const total = String(row.total ?? "0");
+    const hold = String(row.hold ?? "0");
+    const parsed = outcomeFromBalanceCoin(coin);
+    if (parsed) {
+      outcomeBalances.push({ coin, total, hold, outcome: parsed.outcome, side: parsed.side });
+    } else if (coin && !coin.startsWith("#")) {
+      quoteBalances.push({ coin, total, hold });
+    }
+  }
+  const openOrders = [];
+  for (const row of orders ?? []) {
+    const coin = String(row.coin ?? "");
+    const parsed = outcomeFromTradeCoin(coin);
+    if (!parsed) continue;
+    openOrders.push({
+      coin,
+      side: String(row.side ?? ""),
+      limitPx: String(row.limitPx ?? ""),
+      sz: String(row.sz ?? ""),
+      oid: Number(row.oid ?? 0),
+      timestamp: Number(row.timestamp ?? 0),
+      outcome: parsed.outcome,
+      outcomeSide: parsed.side
+    });
+  }
+  return { quoteBalances, outcomeBalances, openOrders };
+}
+
+// src/protocols/evm/hyperliquidOutcome/purpose.ts
+function buildHyperliquidOutcomePurposePrefill(args) {
+  const q = (args.question ?? "").trim();
+  const topic = q ? ` ${q}` : "";
+  const side = args.side === "no" ? "No" : args.side === "yes" ? "Yes" : "";
+  switch (args.action) {
+    case "order": {
+      const dir = args.isBuy === false ? "sell" : "buy";
+      const tif = (args.tif ?? "gtc").toUpperCase();
+      return `Hyperliquid outcome: ${dir} ${side}${topic} ${args.szHuman ?? ""} @ ${args.limitPxHuman ?? ""} ${tif}`.replace(/\s+/g, " ").trim();
+    }
+    case "cancel":
+      return `Hyperliquid outcome: cancel order ${args.oid ?? ""}${topic}`.replace(/\s+/g, " ").trim();
+    case "split":
+      return `Hyperliquid outcome: split ${args.amountHuman ?? ""} quote into Yes+No${topic}`.replace(/\s+/g, " ").trim();
+    case "merge":
+      return `Hyperliquid outcome: merge Yes+No into quote ${args.amountHuman ?? "max"}${topic}`.replace(/\s+/g, " ").trim();
+    case "mergeQuestion":
+      return `Hyperliquid outcome: merge question into quote ${args.amountHuman ?? "max"}${topic}`.replace(/\s+/g, " ").trim();
+    case "negate":
+      return `Hyperliquid outcome: negate ${side || "No"}${topic} ${args.amountHuman ?? ""}`.replace(/\s+/g, " ").trim();
+    default:
+      return "Hyperliquid outcome";
+  }
+}
+
+// src/core/purpose.ts
+function mergePurposeText(purposeText, purposeSuffix) {
+  const t = (purposeText ?? "").trim();
+  const suffix = (purposeSuffix ?? "").trim();
+  if (!suffix) return t;
+  return t ? `${t}
+
+${suffix}` : suffix;
+}
+
+// src/core/envelope.ts
+function finalizeMultisign(input) {
+  const { keyGen, destinationChainID, legs } = input;
+  if (legs.length === 0) {
+    throw new Error("finalizeMultisign requires at least one leg");
+  }
+  const ph = (keyGen.pubkeyhex ?? "").trim();
+  if (!ph) throw new Error("keyGen pubKey (pubkeyhex) is required");
+  const keyList = keyGen.keylist ?? [];
+  const clientId = getClientIdFromKeyGenResult(keyGen);
+  const first = legs[0];
+  const messageHashes = legs.map((l) => l.msgHash);
+  const messageRawBatch = legs.map((l) => l.msgRaw);
+  const batchMeta = legs.map((l) => ({
+    destinationAddress: l.destinationAddress,
+    signatureText: l.signatureText,
+    ...l.audit
+  }));
+  const proposalTxParams = legs.map((l) => l.proposalTxParams).filter((p) => p != null && typeof p === "object");
+  const extraPayload = {
+    batchMeta,
+    ...input.extraJSON ?? {}
+  };
+  const extraJSON = JSON.stringify(extraPayload, (_, v) => typeof v === "bigint" ? v.toString() : v);
+  const bodyForSign = {
+    keyList,
+    pubKey: ph,
+    msgHash: messageHashes[0],
+    msgRaw: first.msgRaw,
+    destinationChainID,
+    destinationAddress: input.destinationAddress ?? first.destinationAddress,
+    extraJSON,
+    signatureText: first.signatureText,
+    purpose: mergePurposeText(input.purposeText, input.purposeSuffix),
+    ...first.feeSnapshot
+  };
+  if (legs.length > 1) {
+    bodyForSign.messageHashes = messageHashes;
+    bodyForSign.messageRawBatch = messageRawBatch;
+  }
+  if (proposalTxParams.length > 0) {
+    bodyForSign.proposalTxParams = proposalTxParams;
+  }
+  const valueWei = first.valueWei;
+  if (valueWei != null && valueWei > 0n) {
+    bodyForSign.value = valueWei.toString();
+  }
+  if (clientId) bodyForSign.clientId = clientId;
+  if (input.expiryDate != null && input.expiryDate > 0) {
+    bodyForSign.expiryDate = Math.floor(input.expiryDate);
+  }
+  return { bodyForSign, messageToSign: JSON.stringify(bodyForSign) };
+}
+
+// src/core/eip712Multisign.ts
+var EIP712_SIGN_REQUEST_KIND = "eip712";
+function msgHashNo0x(digest) {
+  return digest.startsWith("0x") ? digest.slice(2) : digest;
+}
+function eip712SignatureText(domain, primaryType) {
+  return JSON.stringify({
+    kind: "EIP-712",
+    ...typeof domain.name === "string" ? { name: domain.name } : {},
+    primaryType
+  });
+}
+function jsonStringifyForAudit(value) {
+  return JSON.stringify(value, (_, v) => typeof v === "bigint" ? v.toString() : v);
+}
+function eip712LegEnvelope(typedData, delivery, digest) {
+  return {
+    version: 1,
+    digest,
+    domain: typedData.domain,
+    types: typedData.types,
+    primaryType: typedData.primaryType,
+    message: typedData.message,
+    delivery
+  };
+}
+function eip712MsgRawHex(envelope) {
+  return stringToHex(jsonStringifyForAudit(envelope));
+}
+function buildEip712Multisign(args) {
+  if (args.legs.length < 1) {
+    throw new Error("buildEip712Multisign requires at least one leg");
+  }
+  const eip712 = [];
+  const legs = args.legs.map((leg) => {
+    const digest = hashTypedData({
+      domain: leg.typedData.domain,
+      types: leg.typedData.types,
+      primaryType: leg.typedData.primaryType,
+      message: leg.typedData.message
+    });
+    const envelope = eip712LegEnvelope(leg.typedData, leg.delivery, digest);
+    eip712.push(envelope);
+    return {
+      msgHash: msgHashNo0x(digest),
+      msgRaw: eip712MsgRawHex(envelope),
+      destinationAddress: args.destinationAddress,
+      signatureText: eip712SignatureText(leg.typedData.domain, leg.typedData.primaryType),
+      audit: {
+        kind: "EIP712",
+        primaryType: leg.typedData.primaryType,
+        deliveryKind: leg.delivery.kind,
+        ...leg.audit ?? {}
+      },
+      feeSnapshot: {}
+    };
+  });
+  return finalizeMultisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    purposeSuffix: args.purposeSuffix,
+    destinationChainID: args.destinationChainID,
+    destinationAddress: args.destinationAddress,
+    extraJSON: {
+      signRequestKind: EIP712_SIGN_REQUEST_KIND,
+      eip712
+    },
+    expiryDate: args.expiryDate,
+    legs
+  });
+}
+
+// src/core/expiry.ts
+var DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS = 30 * 60;
+var DEFI_PROTOCOLS_WITH_30MIN_EXPIRY = /* @__PURE__ */ new Set([
+  "uniswap-v4",
+  "gmx",
+  "hyperliquid",
+  "arcus",
+  "curve-dao",
+  "aerodrome",
+  "pendle",
+  "derive",
+  "trueo",
+  "hyperliquidOutcome"
+]);
+function defiMultisignExpiryUnixSeconds(protocolId, explicitExpiryDate) {
+  if (typeof explicitExpiryDate === "number" && Number.isFinite(explicitExpiryDate) && explicitExpiryDate > 0) {
+    return Math.floor(explicitExpiryDate);
+  }
+  if (DEFI_PROTOCOLS_WITH_30MIN_EXPIRY.has(protocolId)) {
+    return Math.floor(Date.now() / 1e3) + DEFAULT_DEFI_MULTISIGN_EXPIRY_SECONDS;
+  }
+  return void 0;
+}
+var EXCHANGE_DOMAIN = {
+  name: "Exchange",
+  version: "1",
+  chainId: 1337,
+  verifyingContract: "0x0000000000000000000000000000000000000000"
+};
+var AGENT_TYPES = {
+  Agent: [
+    { name: "source", type: "string" },
+    { name: "connectionId", type: "bytes32" }
+  ]
+};
+function adjustMsgpackValue(value) {
+  if (Array.isArray(value)) return value.map(adjustMsgpackValue);
+  if (typeof value === "object" && value !== null) {
+    const result = {};
+    for (const key of Object.keys(value)) {
+      const entry = value[key];
+      if (entry !== void 0) result[key] = adjustMsgpackValue(entry);
+    }
+    return result;
+  }
+  if (typeof value === "number" && Number.isInteger(value) && (value >= 4294967296 || value < -2147483648)) {
+    return BigInt(value);
+  }
+  return value;
+}
+function toUint64Bytes(n) {
+  const bytes = new Uint8Array(8);
+  new DataView(bytes.buffer).setBigUint64(0, BigInt(n));
+  return bytes;
+}
+function concatBytes(...parts) {
+  const total = parts.reduce((sum, p) => sum + p.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const p of parts) {
+    out.set(p, offset);
+    offset += p.length;
+  }
+  return out;
+}
+function hexToBytes(hex) {
+  const h = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(h.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function createHyperliquidL1ActionHash(args) {
+  const { action, nonce, vaultAddress, expiresAfter } = args;
+  const actionBytes = encode(adjustMsgpackValue(action));
+  const nonceBytes = toUint64Bytes(nonce);
+  const vaultMarker = vaultAddress ? new Uint8Array([1]) : new Uint8Array([0]);
+  const vaultBytes = vaultAddress ? hexToBytes(vaultAddress) : new Uint8Array();
+  const expiresMarker = expiresAfter !== void 0 ? new Uint8Array([0]) : new Uint8Array();
+  const expiresBytes = expiresAfter !== void 0 ? toUint64Bytes(expiresAfter) : new Uint8Array();
+  const bytes = concatBytes(actionBytes, nonceBytes, vaultMarker, vaultBytes, expiresMarker, expiresBytes);
+  return keccak256(bytes);
+}
+function buildHyperliquidAgentTypedData(args) {
+  const connectionId = createHyperliquidL1ActionHash(args);
+  const source = args.isTestnet ? "b" : "a";
+  return {
+    domain: EXCHANGE_DOMAIN,
+    types: AGENT_TYPES,
+    primaryType: "Agent",
+    message: {
+      source,
+      connectionId
+    },
+    connectionId,
+    nonce: args.nonce,
+    action: args.action
+  };
+}
+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.");
+  const rounded = n.toFixed(8);
+  if (Math.abs(Number.parseFloat(rounded) - n) >= 1e-12) {
+    throw new Error(`Hyperliquid wire value ${value} has too many decimal places.`);
+  }
+  const normalized = Number(rounded === "-0" ? "0" : rounded);
+  return String(normalized);
+}
+function hyperliquidL1TifFromKey(tif) {
+  const key = String(tif ?? "gtc").trim().toLowerCase();
+  if (key === "alo") return "Alo";
+  if (key === "ioc") return "Ioc";
+  if (key === "gtc") return "Gtc";
+  throw new Error(`Unknown time-in-force: ${tif}. Use alo, gtc, or ioc.`);
+}
+function buildHyperliquidLimitOrderWire(args) {
+  return {
+    a: args.asset,
+    b: args.isBuy,
+    p: hyperliquidFloatToWire(args.limitPxHuman),
+    s: hyperliquidFloatToWire(args.szHuman),
+    r: Boolean(args.reduceOnly),
+    t: { limit: { tif: hyperliquidL1TifFromKey(args.tif) } }
+  };
+}
+function buildHyperliquidOrderAction(args) {
+  return {
+    type: "order",
+    orders: args.orders,
+    grouping: args.grouping ?? "na"
+  };
+}
+
+// src/protocols/evm/hyperliquidOutcome/multisign.ts
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function assertOutcomeChain(chainId) {
+  if (!isHyperliquidChainSupported(chainId)) {
+    throw new Error(`Hyperliquid outcome markets require chainId 999 or 998 (got ${chainId}).`);
+  }
+}
+function outcomeExchangeLeg(args) {
+  const isTestnet = args.chainId === 998;
+  const typed = buildHyperliquidAgentTypedData({
+    action: args.action,
+    nonce: args.nonce,
+    isTestnet
+  });
+  return {
+    typedData: {
+      domain: typed.domain,
+      types: typed.types,
+      primaryType: typed.primaryType,
+      message: typed.message
+    },
+    delivery: {
+      kind: "hyperliquid_exchange",
+      chainId: args.chainId,
+      isTestnet,
+      action: args.action,
+      nonce: args.nonce
+    },
+    audit: {
+      ...args.audit,
+      nonce: args.nonce,
+      connectionId: typed.connectionId
+    }
+  };
+}
+function finishOutcomeMultisign(args, leg) {
+  assertOutcomeChain(args.chainId);
+  const expiryDate = defiMultisignExpiryUnixSeconds(HYPERLIQUID_OUTCOME_PROTOCOL_ID, args.expiryDate);
+  return buildEip712Multisign({
+    keyGen: args.keyGen,
+    purposeText: args.purposeText,
+    destinationChainID: String(args.chainId),
+    destinationAddress: ZERO_ADDRESS,
+    expiryDate,
+    legs: [leg]
+  });
+}
+function buildHyperliquidOutcomeOrderAction(args) {
+  const encoding = outcomeEncoding(args.outcome, outcomeSideIndex(args.side));
+  const asset = outcomeAssetId(encoding);
+  return {
+    encoding,
+    coin: outcomeTradeCoin(encoding),
+    asset,
+    action: buildHyperliquidOrderAction({
+      orders: [
+        buildHyperliquidLimitOrderWire({
+          asset,
+          isBuy: args.isBuy,
+          limitPxHuman: args.limitPxHuman,
+          szHuman: args.szHuman,
+          tif: args.tif,
+          reduceOnly: args.reduceOnly
+        })
+      ],
+      grouping: "na"
+    })
+  };
+}
+async function buildEvmMultisignBodyHyperliquidOutcomeOrder(args) {
+  const built = buildHyperliquidOutcomeOrderAction(args);
+  const nonce = args.nonce ?? Date.now();
+  return finishOutcomeMultisign(
+    args,
+    outcomeExchangeLeg({
+      action: built.action,
+      nonce,
+      chainId: args.chainId,
+      audit: {
+        protocol: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+        action: "order",
+        outcome: args.outcome,
+        side: args.side,
+        coin: built.coin,
+        asset: built.asset,
+        isBuy: args.isBuy,
+        limitPxHuman: args.limitPxHuman,
+        szHuman: args.szHuman
+      }
+    })
+  );
+}
+function buildHyperliquidOutcomeCancelAction(args) {
+  const encoding = outcomeEncoding(args.outcome, outcomeSideIndex(args.side));
+  const asset = outcomeAssetId(encoding);
+  const oid = Math.trunc(args.oid);
+  if (!Number.isFinite(oid) || oid <= 0) throw new Error("oid must be a positive order id");
+  return {
+    encoding,
+    coin: outcomeTradeCoin(encoding),
+    asset,
+    action: {
+      type: "cancel",
+      cancels: [{ a: asset, o: oid }]
+    }
+  };
+}
+async function buildEvmMultisignBodyHyperliquidOutcomeCancel(args) {
+  const built = buildHyperliquidOutcomeCancelAction(args);
+  const nonce = args.nonce ?? Date.now();
+  return finishOutcomeMultisign(
+    args,
+    outcomeExchangeLeg({
+      action: built.action,
+      nonce,
+      chainId: args.chainId,
+      audit: {
+        protocol: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+        action: "cancel",
+        outcome: args.outcome,
+        side: args.side,
+        oid: args.oid,
+        coin: built.coin,
+        asset: built.asset
+      }
+    })
+  );
+}
+function positiveWireAmount(amountHuman, label) {
+  const wire = hyperliquidFloatToWire(amountHuman);
+  if (Number.parseFloat(wire) <= 0) throw new Error(`${label} must be greater than zero`);
+  return wire;
+}
+function buildHyperliquidOutcomeSplitAction(args) {
+  const outcome = Math.trunc(args.outcome);
+  outcomeEncoding(outcome, 0);
+  return {
+    type: "userOutcome",
+    splitOutcome: { outcome, amount: positiveWireAmount(args.amountHuman, "amount") }
+  };
+}
+async function buildEvmMultisignBodyHyperliquidOutcomeSplit(args) {
+  const action = buildHyperliquidOutcomeSplitAction(args);
+  const nonce = args.nonce ?? Date.now();
+  return finishOutcomeMultisign(
+    args,
+    outcomeExchangeLeg({
+      action,
+      nonce,
+      chainId: args.chainId,
+      audit: {
+        protocol: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+        action: "split",
+        outcome: action.splitOutcome.outcome,
+        amount: action.splitOutcome.amount
+      }
+    })
+  );
+}
+function buildHyperliquidOutcomeMergeAction(args) {
+  const outcome = Math.trunc(args.outcome);
+  outcomeEncoding(outcome, 0);
+  const amount = args.amountMax || !args.amountHuman?.trim() ? null : positiveWireAmount(args.amountHuman, "amount");
+  return {
+    type: "userOutcome",
+    mergeOutcome: { outcome, amount }
+  };
+}
+async function buildEvmMultisignBodyHyperliquidOutcomeMerge(args) {
+  const action = buildHyperliquidOutcomeMergeAction(args);
+  const nonce = args.nonce ?? Date.now();
+  return finishOutcomeMultisign(
+    args,
+    outcomeExchangeLeg({
+      action,
+      nonce,
+      chainId: args.chainId,
+      audit: {
+        protocol: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+        action: "merge",
+        outcome: action.mergeOutcome.outcome,
+        amount: action.mergeOutcome.amount
+      }
+    })
+  );
+}
+function buildHyperliquidOutcomeMergeQuestionAction(args) {
+  const question = Math.trunc(args.question);
+  if (!Number.isFinite(question) || question < 0) throw new Error("question must be a non-negative integer");
+  const amount = args.amountMax || !args.amountHuman?.trim() ? null : positiveWireAmount(args.amountHuman, "amount");
+  return {
+    type: "userOutcome",
+    mergeQuestion: { question, amount }
+  };
+}
+async function buildEvmMultisignBodyHyperliquidOutcomeMergeQuestion(args) {
+  const action = buildHyperliquidOutcomeMergeQuestionAction(args);
+  const nonce = args.nonce ?? Date.now();
+  return finishOutcomeMultisign(
+    args,
+    outcomeExchangeLeg({
+      action,
+      nonce,
+      chainId: args.chainId,
+      audit: {
+        protocol: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+        action: "mergeQuestion",
+        question: action.mergeQuestion.question,
+        amount: action.mergeQuestion.amount
+      }
+    })
+  );
+}
+function buildHyperliquidOutcomeNegateAction(args) {
+  const question = Math.trunc(args.question);
+  const outcome = Math.trunc(args.outcome);
+  if (!Number.isFinite(question) || question < 0) throw new Error("question must be a non-negative integer");
+  outcomeEncoding(outcome, 0);
+  return {
+    type: "userOutcome",
+    negateOutcome: {
+      question,
+      outcome,
+      amount: positiveWireAmount(args.amountHuman, "amount")
+    }
+  };
+}
+async function buildEvmMultisignBodyHyperliquidOutcomeNegate(args) {
+  const action = buildHyperliquidOutcomeNegateAction(args);
+  const nonce = args.nonce ?? Date.now();
+  return finishOutcomeMultisign(
+    args,
+    outcomeExchangeLeg({
+      action,
+      nonce,
+      chainId: args.chainId,
+      audit: {
+        protocol: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+        action: "negate",
+        question: action.negateOutcome.question,
+        outcome: action.negateOutcome.outcome,
+        amount: action.negateOutcome.amount
+      }
+    })
+  );
+}
+
+// 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
+  };
+}
+async function hyperliquidOutcomeFetchMarketsSummary(input) {
+  const chainId = input.chainId ?? HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID;
+  const { markets } = await listHyperliquidOutcomeMarkets({ chainId, query: input.query });
+  const offset = Math.max(input.offset ?? 0, 0);
+  const limit = input.limit ?? 20;
+  const page = markets.slice(offset, offset + limit);
+  const nextOffset = offset + page.length;
+  return {
+    markets: page,
+    hasMore: nextOffset < markets.length,
+    nextOffset,
+    notes: page.length ? `${page.length} Hyperliquid outcome market(s). Yes price is the implied probability. Writes need load_defi_protocol hyperliquidOutcome.` : "No Hyperliquid outcome markets matched."
+  };
+}
+async function hyperliquidOutcomeFetchMarketSummary(input) {
+  const chainId = input.chainId ?? HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID;
+  const market = await getHyperliquidOutcomeMarket({ chainId, outcomeId: input.outcome });
+  const [yesBook, noBook] = await Promise.all([
+    fetchHyperliquidOutcomeBook({ chainId, coin: market.yesCoin }),
+    fetchHyperliquidOutcomeBook({ chainId, coin: market.noCoin })
+  ]);
+  return {
+    ...market,
+    yesBook,
+    noBook,
+    notes: "Books are HyperCore l2Book for the #encoding coins. Do not add Yes/No shares to the node token list."
+  };
+}
+async function hyperliquidOutcomeFetchOrderbookSummary(input) {
+  const chainId = input.chainId ?? HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID;
+  const side = input.side ?? "yes";
+  const market = await getHyperliquidOutcomeMarket({ chainId, outcomeId: input.outcome });
+  const coin = side === "no" ? market.noCoin : market.yesCoin;
+  const book = await fetchHyperliquidOutcomeBook({ chainId, coin });
+  return {
+    outcome: market.outcome,
+    side,
+    book,
+    notes: `${side} book for ${coin}.`
+  };
+}
+async function hyperliquidOutcomeFetchPositionsSummary(input) {
+  const chainId = input.chainId ?? HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID;
+  const account = await fetchHyperliquidOutcomeAccount({ chainId, user: input.user });
+  return {
+    quoteBalances: account.quoteBalances,
+    outcomeBalances: account.outcomeBalances,
+    notes: "Outcome shares are HyperCore balances (+encoding), not ERC20s. Do not call add_to_token_registry."
+  };
+}
+async function hyperliquidOutcomeFetchOpenOrdersSummary(input) {
+  const chainId = input.chainId ?? HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID;
+  const account = await fetchHyperliquidOutcomeAccount({ chainId, user: input.user });
+  return {
+    openOrders: account.openOrders,
+    notes: account.openOrders.length ? "Cancel with ctm_hyperliquid_outcome_build_cancel_multisign using outcome, side, and oid." : "No open Hyperliquid outcome orders."
+  };
+}
+
+// src/protocols/evm/hyperliquidOutcome/index.ts
+var hyperliquidOutcomeProtocolModule = {
+  id: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+  chainCategory: "evm",
+  isChainSupported(ctx) {
+    if (ctx.chainCategory !== "evm") return false;
+    const chainId = typeof ctx.chainId === "number" ? ctx.chainId : Number(ctx.chainId);
+    return Number.isFinite(chainId) && isHyperliquidChainSupported(chainId);
+  },
+  isTokenSupported(token) {
+    return token.category === "evm" && token.kind === "native";
+  },
+  actions: [
+    {
+      id: "hyperliquidOutcome.order",
+      protocolId: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Limit buy or sell a HIP-4 outcome side via Hyperliquid /exchange",
+      commonParams: ["keyGen", "purposeText"],
+      params: {}
+    },
+    {
+      id: "hyperliquidOutcome.cancel",
+      protocolId: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Cancel a resting HIP-4 outcome order",
+      commonParams: ["keyGen", "purposeText"],
+      params: {}
+    },
+    {
+      id: "hyperliquidOutcome.split",
+      protocolId: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Split quote tokens into Yes and No shares",
+      commonParams: ["keyGen", "purposeText"],
+      params: {}
+    },
+    {
+      id: "hyperliquidOutcome.merge",
+      protocolId: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Merge Yes and No shares back into quote tokens",
+      commonParams: ["keyGen", "purposeText"],
+      params: {}
+    },
+    {
+      id: "hyperliquidOutcome.merge-question",
+      protocolId: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Merge Yes shares across a question into quote tokens",
+      commonParams: ["keyGen", "purposeText"],
+      params: {}
+    },
+    {
+      id: "hyperliquidOutcome.negate",
+      protocolId: HYPERLIQUID_OUTCOME_PROTOCOL_ID,
+      chainCategory: "evm",
+      description: "Convert No shares of one outcome into Yes shares of the other outcomes",
+      commonParams: ["keyGen", "purposeText"],
+      params: {}
+    }
+  ]
+};
+registerProtocolModule(hyperliquidOutcomeProtocolModule);
+
+export { HYPERLIQUID_OUTCOME_MAINNET_CHAIN_ID, HYPERLIQUID_OUTCOME_PROTOCOL_ID, buildEvmMultisignBodyHyperliquidOutcomeCancel, buildEvmMultisignBodyHyperliquidOutcomeMerge, buildEvmMultisignBodyHyperliquidOutcomeMergeQuestion, buildEvmMultisignBodyHyperliquidOutcomeNegate, buildEvmMultisignBodyHyperliquidOutcomeOrder, buildEvmMultisignBodyHyperliquidOutcomeSplit, buildHyperliquidOutcomeCancelAction, buildHyperliquidOutcomeMergeAction, buildHyperliquidOutcomeMergeQuestionAction, buildHyperliquidOutcomeNegateAction, buildHyperliquidOutcomeOrderAction, buildHyperliquidOutcomePurposePrefill, buildHyperliquidOutcomeSplitAction, clearHyperliquidOutcomeMetaCache, fetchHyperliquidOutcomeAccount, fetchHyperliquidOutcomeBook, fetchHyperliquidOutcomeChanceSeries, fillOutcomeTemplate, formatHyperliquidStamp, formatOutcomeQuestion, formatOutcomeRules, getHyperliquidOutcomeMarket, hyperliquidOutcomeFetchMarketSummary, hyperliquidOutcomeFetchMarketsSummary, hyperliquidOutcomeFetchOpenOrdersSummary, hyperliquidOutcomeFetchOrderbookSummary, hyperliquidOutcomeFetchPositionsSummary, hyperliquidOutcomeMatchesQuery, hyperliquidOutcomeProtocolModule, hyperliquidOutcomeToPredictionFields, listHyperliquidOutcomeMarkets, outcomeAssetId, outcomeBalanceCoin, outcomeEncoding, outcomeExpiryUnix, outcomeFieldMap, outcomeSideIndex, outcomeSideName, outcomeTemplateId, outcomeTradeCoin, parseHyperliquidPipeFields, parseHyperliquidStamp, questionForOutcome, resolveOutcomeSideLabel };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map