@oracle-agent/oracle 0.1.0

package/scripts/build-inscription.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""Build the Oracle inscription SVG.
+
+Text is converted to OUTLINED VECTOR PATHS so the inscription is fully
+self-contained: no font file, no external fetch, no <text> element that renders
+differently in every ordinals explorer. Design language is the Oracle splash:
+deep #0B1018 field, #7CC4FF blue, Cormorant Garamond display italic accent,
+IBM Plex Mono eyebrow, a single luminous orb.
+"""
+
+import math
+import os
+
+from fontTools.ttLib import TTFont
+from fontTools.pens.svgPathPen import SVGPathPen
+from fontTools.varLib.instancer import instantiateVariableFont
+
+import os
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+W, H = 1000, 1000
+
+BG = "#0B1018"
+BLUE = "#7CC4FF"
+BLUE2 = "#A7D8FF"
+COOL = "#9BB6D1"
+MUTE = "#5B738F"
+
+# vertical rhythm
+CX = W / 2.0
+CY = 336.0
+R_OUT = 166.0
+R_MID = 128.0
+R_IN = 92.0
+MARK_BASELINE = 690.0
+SUB_BASELINE = 786.0
+
+
+def load(path, wght):
+    f = TTFont(path)
+    if "fvar" in f:
+        f = instantiateVariableFont(f, {"wght": wght}, inplace=False, updateFontNames=False)
+    return f
+
+
+def text_paths(font, text, size, letter_spacing=0.0):
+    """Return (path_d, advance_width) with the text laid out at `size` px."""
+    upem = font["head"].unitsPerEm
+    scale = size / upem
+    cmap = font.getBestCmap()
+    gs = font.getGlyphSet()
+    hmtx = font["hmtx"]
+
+    try:
+        kern = font["kern"].kernTables[0].kernTable
+    except Exception:
+        kern = None
+
+    parts = []
+    x = 0.0
+    prev = None
+
+    for ch in text:
+        gname = cmap.get(ord(ch))
+        if gname is None:
+            x += size * 0.3
+            prev = None
+            continue
+        if prev and kern:
+            x += kern.get((prev, gname), 0) * scale
+        pen = SVGPathPen(gs)
+        gs[gname].draw(pen)
+        d = pen.getCommands()
+        if d:
+            # flip Y (font space is y-up, SVG is y-down) and place at x
+            parts.append(
+                f'<g transform="translate({x:.3f},0) scale({scale:.6f},{-scale:.6f})">'
+                f'<path d="{d}"/></g>'
+            )
+        x += hmtx[gname][0] * scale + letter_spacing
+        prev = gname
+    # trailing letter-spacing is not part of the inked width
+    if letter_spacing and text:
+        x -= letter_spacing
+    return "".join(parts), x
+
+
+def centered(font, text, size, y, fill, letter_spacing=0.0, opacity=None):
+    d, width = text_paths(font, text, size, letter_spacing)
+    if not d:
+        return ""
+    x = (W - width) / 2.0
+    op = f' opacity="{opacity}"' if opacity is not None else ""
+    return f'<g transform="translate({x:.3f},{y:.3f})" fill="{fill}"{op}>{d}</g>'
+
+
+def arc(cx, cy, r, a0, a1):
+    """SVG arc path between two angles in degrees."""
+    x0 = cx + math.cos(math.radians(a0)) * r
+    y0 = cy + math.sin(math.radians(a0)) * r
+    x1 = cx + math.cos(math.radians(a1)) * r
+    y1 = cy + math.sin(math.radians(a1)) * r
+    large = 1 if abs(a1 - a0) > 180 else 0
+    sweep = 1 if a1 > a0 else 0
+    return f"M{x0:.2f} {y0:.2f} A{r} {r} 0 {large} {sweep} {x1:.2f} {y1:.2f}"
+
+
+def main():
+    display_italic = load("/tmp/CormorantGaramond-Italic.ttf", 400)
+    display = load("/tmp/CormorantGaramond.ttf", 300)
+    mono = TTFont(os.environ.get("IBM_PLEX_MONO", str(Path.home() / ".local/share/fonts/protocols/IBMPlexMono-Regular.ttf")))
+
+    o = []
+    o.append(f'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 {W} {H}" width="{W}" height="{H}">')
+
+    o.append(
+        "<defs>"
+        '<radialGradient id="halo" cx="50%" cy="34%" r="54%">'
+        f'<stop offset="0%" stop-color="{BLUE}" stop-opacity=".20"/>'
+        f'<stop offset="52%" stop-color="{BLUE}" stop-opacity=".05"/>'
+        f'<stop offset="100%" stop-color="{BLUE}" stop-opacity="0"/>'
+        "</radialGradient>"
+        '<radialGradient id="orb" cx="50%" cy="50%" r="50%">'
+        '<stop offset="0%" stop-color="#F2FAFF"/>'
+        f'<stop offset="38%" stop-color="{BLUE2}"/>'
+        f'<stop offset="100%" stop-color="{BLUE}" stop-opacity=".14"/>'
+        "</radialGradient>"
+        '<linearGradient id="rule" x1="0" y1="0" x2="1" y2="0">'
+        f'<stop offset="0%" stop-color="{BLUE}" stop-opacity="0"/>'
+        f'<stop offset="50%" stop-color="{BLUE}" stop-opacity=".6"/>'
+        f'<stop offset="100%" stop-color="{BLUE}" stop-opacity="0"/>'
+        "</linearGradient>"
+        '<linearGradient id="sweep" x1="0" y1="0" x2="1" y2="1">'
+        f'<stop offset="0%" stop-color="{BLUE}" stop-opacity="0"/>'
+        '<stop offset="100%" stop-color="#EAF6FF" stop-opacity=".95"/>'
+        "</linearGradient>"
+        "</defs>"
+    )
+
+    o.append(f'<rect width="{W}" height="{H}" fill="{BG}"/>')
+    o.append(f'<rect width="{W}" height="{H}" fill="url(#halo)"/>')
+
+    # --- orbit rings: readable at thumbnail size --------------------------
+    o.append(
+        f'<circle cx="{CX}" cy="{CY}" r="{R_OUT}" fill="none" '
+        f'stroke="{BLUE}" stroke-opacity=".24" stroke-width="1.1"/>'
+    )
+    o.append(
+        f'<circle cx="{CX}" cy="{CY}" r="{R_MID}" fill="none" '
+        f'stroke="{BLUE}" stroke-opacity=".16" stroke-width="1"/>'
+    )
+    o.append(
+        f'<circle cx="{CX}" cy="{CY}" r="{R_IN}" fill="none" '
+        f'stroke="{BLUE}" stroke-opacity=".34" stroke-width="1" stroke-dasharray="1.5 7"/>'
+    )
+
+    # the agentic sweep: one bright arc, the thing that is moving
+    o.append(
+        f'<path d="{arc(CX, CY, R_OUT, -96, 4)}" fill="none" '
+        'stroke="url(#sweep)" stroke-width="2.2" stroke-linecap="round"/>'
+    )
+
+    # 8 lane ticks on the outer ring
+    for i in range(8):
+        a = math.radians(-90 + i * 45)
+        x1 = CX + math.cos(a) * R_OUT
+        y1 = CY + math.sin(a) * R_OUT
+        x2 = CX + math.cos(a) * (R_OUT - 13)
+        y2 = CY + math.sin(a) * (R_OUT - 13)
+        o.append(
+            f'<line x1="{x1:.2f}" y1="{y1:.2f}" x2="{x2:.2f}" y2="{y2:.2f}" '
+            f'stroke="{BLUE}" stroke-opacity=".5" stroke-width="1.5"/>'
+        )
+
+    # node dots on the mid ring
+    for i in range(4):
+        a = math.radians(-45 + i * 90)
+        x = CX + math.cos(a) * R_MID
+        y = CY + math.sin(a) * R_MID
+        o.append(f'<circle cx="{x:.2f}" cy="{y:.2f}" r="2.6" fill="{BLUE}" opacity=".72"/>')
+
+    # --- the orb ----------------------------------------------------------
+    o.append(f'<circle cx="{CX}" cy="{CY}" r="52" fill="url(#orb)" opacity=".20"/>')
+    o.append(f'<circle cx="{CX}" cy="{CY}" r="16" fill="url(#orb)"/>')
+    o.append(
+        f'<circle cx="{CX}" cy="{CY}" r="16" fill="none" '
+        'stroke="#F2FAFF" stroke-opacity=".55" stroke-width=".9"/>'
+    )
+
+    # --- eyebrow ----------------------------------------------------------
+    o.append(centered(mono, "ORACLE", 16, 122, BLUE, letter_spacing=7.4))
+    o.append(f'<rect x="{CX - 84}" y="143" width="168" height="1" fill="url(#rule)"/>')
+
+    # --- the mark ---------------------------------------------------------
+    o.append(centered(display_italic, "oracle", 178, MARK_BASELINE, BLUE2))
+    o.append(centered(display, "was here", 92, SUB_BASELINE, COOL, opacity=".9"))
+
+    # --- footer -----------------------------------------------------------
+    o.append(f'<rect x="{CX - 132}" y="836" width="264" height="1" fill="url(#rule)"/>')
+    o.append(centered(mono, "THE FUTURE IS AGENTIC", 14.5, 880, BLUE, letter_spacing=4.0))
+    o.append(centered(mono, "BITCOIN L1", 12, 916, MUTE, letter_spacing=3.4))
+
+    # --- corner registration marks ---------------------------------------
+    m, ln = 52, 24
+    for (x, y, dx, dy) in ((m, m, 1, 1), (W - m, m, -1, 1), (m, H - m, 1, -1), (W - m, H - m, -1, -1)):
+        o.append(
+            f'<path d="M{x} {y + dy * ln} L{x} {y} L{x + dx * ln} {y}" fill="none" '
+            f'stroke="{BLUE}" stroke-opacity=".38" stroke-width="1.3"/>'
+        )
+
+    o.append("</svg>")
+
+    svg = "".join(o)
+    path = str(REPO_ROOT / "artifacts/inscription/oracle-was-here.svg")
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    with open(path, "w") as f:
+        f.write(svg)
+
+    # sanity: the mark must not collide with the ring group
+    mark_cap_top = MARK_BASELINE - 178 * 0.74
+    ring_bottom = CY + R_OUT
+    print(f"wrote {path}")
+    print(f"bytes {len(svg.encode())}")
+    print(f"ring_bottom={ring_bottom:.1f} mark_cap_top={mark_cap_top:.1f} clearance={mark_cap_top - ring_bottom:.1f}px")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/check-test-count.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+// Test-count drift gate.
+//
+// Two agents push to this branch. Each one runs the suite in its own tree and
+// reports a number. Those numbers drift: round 7 landed a commit message
+// claiming "707 tests, 0 failing" when the tree at that commit actually ran
+// 729. Nobody lied — the claim was just written against a stale checkout, and
+// git history keeps it forever.
+//
+// So the count is committed alongside the code. Add or remove a test and the
+// build fails until the baseline is updated in the SAME commit, which puts the
+// delta in the diff where review can see it. A stale claim becomes a red build
+// instead of a permanent wrong number in the log.
+//
+//   node scripts/check-test-count.mjs            verify against the baseline
+//   node scripts/check-test-count.mjs --update   rewrite it (intentional change)
+
+import { spawnSync } from "node:child_process";
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { dirname, join, resolve } from "node:path";
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const BASELINE = join(ROOT, "test-baseline.json");
+const UPDATE = process.argv.includes("--update");
+
+// Run the suite exactly the way `npm test` does, so the gate can never pass
+// against a different set of files or env than the suite CI actually runs.
+const pkg = JSON.parse(readFileSync(join(ROOT, "package.json"), "utf8"));
+const testCmd = pkg.scripts?.test;
+if (!testCmd) {
+  console.error("check-test-count: package.json has no test script");
+  process.exit(1);
+}
+
+const run = spawnSync("sh", ["-c", testCmd], {
+  cwd: ROOT,
+  encoding: "utf8",
+  maxBuffer: 64 * 1024 * 1024,
+});
+
+const output = `${run.stdout || ""}${run.stderr || ""}`;
+
+// node --test emits two different summary formats. Interactive (TTY) gives the
+// spec reporter's "ℹ tests 729". Non-interactive — which is every CI run —
+// gives TAP: "# tests 729". Parsing only the first shape passed locally and
+// failed in CI, which is the same stale-measurement class this gate exists to
+// catch, so match both anchored to line start. A test NAME containing
+// "tests 999" lives on an "ok N - ..." line and cannot reach either pattern.
+function summaryValue(label) {
+  const m = output.match(new RegExp(`^\\s*(?:ℹ|i|#)\\s+${label}\\s+(\\d+)\\s*$`, "m"));
+  return m ? Number(m[1]) : null;
+}
+
+const actual = {
+  tests: summaryValue("tests"),
+  pass: summaryValue("pass"),
+  fail: summaryValue("fail"),
+  skipped: summaryValue("skipped"),
+};
+
+if (actual.tests == null || actual.pass == null || actual.fail == null) {
+  console.error("check-test-count: could not parse the node --test summary.");
+  console.error(output.slice(-2000));
+  process.exit(1);
+}
+
+// A red suite is the suite step's job to report, but never let a failing run
+// silently rewrite the baseline.
+if (actual.fail > 0) {
+  console.error(`check-test-count: suite is RED (${actual.fail} failing) — refusing to gate or update.`);
+  console.error(output.slice(-4000));
+  process.exit(1);
+}
+
+if (UPDATE) {
+  writeFileSync(BASELINE, `${JSON.stringify(actual, null, 2)}\n`);
+  console.log(`check-test-count: baseline updated -> ${JSON.stringify(actual)}`);
+  console.log("Commit test-baseline.json in the same commit as the test change.");
+  process.exit(0);
+}
+
+if (!existsSync(BASELINE)) {
+  console.error(`check-test-count: ${BASELINE} is missing. Create it with --update.`);
+  process.exit(1);
+}
+
+const expected = JSON.parse(readFileSync(BASELINE, "utf8"));
+const drifted = ["tests", "pass", "fail", "skipped"].filter(
+  (k) => Number(expected[k]) !== Number(actual[k]),
+);
+
+if (drifted.length) {
+  console.error("check-test-count: TEST COUNT DRIFT");
+  console.error(`  expected  ${JSON.stringify(expected)}`);
+  console.error(`  actual    ${JSON.stringify(actual)}`);
+  console.error(`  differs   ${drifted.join(", ")}`);
+  console.error("");
+  console.error("If this change is intentional, run:");
+  console.error("  npm run test:count:update");
+  console.error("and commit test-baseline.json alongside the test change.");
+  process.exit(1);
+}
+
+console.log(`check-test-count: PASS — ${JSON.stringify(actual)} matches the committed baseline`);

package/scripts/e2e-hl-markets.mjs

@@ -0,0 +1,21 @@
+import { data as desk } from "../src/data/desk-data.mjs";
+
+const board = await desk.call("hl-markets", "markets", {});
+console.log(`markets: ${board.count} live perps`);
+console.log(`total OI:  $${(board.totals.openInterestUsd / 1e9).toFixed(2)}B`);
+console.log(`24h vol:   $${(board.totals.dayNtlVolumeUsd / 1e9).toFixed(2)}B`);
+
+const btc = board.markets.find((m) => m.coin === "BTC");
+console.log(`\nBTC  mark=$${btc.markPx}  24h=${btc.change24hPct?.toFixed(2)}%  OI=$${(btc.openInterestUsd / 1e6).toFixed(1)}M  fundingAPR=${btc.fundingRateAprPct?.toFixed(2)}%  maxLev=${btc.maxLeverage}x`);
+
+const lb = await desk.call("hl-markets", "leaderboards", { limit: 3 });
+console.log(`\ntop gainers:  ${lb.gainers.map((m) => `${m.coin} ${m.change24hPct.toFixed(1)}%`).join(", ")}`);
+console.log(`top losers:   ${lb.losers.map((m) => `${m.coin} ${m.change24hPct.toFixed(1)}%`).join(", ")}`);
+console.log(`by volume:    ${lb.byVolume.map((m) => `${m.coin} $${(m.dayNtlVolumeUsd / 1e6).toFixed(0)}M`).join(", ")}`);
+console.log(`funding high: ${lb.fundingHighest.map((m) => `${m.coin} ${m.fundingRateAprPct.toFixed(1)}%`).join(", ")}`);
+
+const hype = await desk.call("hl-markets", "coin", { coin: "HYPE", interval: "1h" });
+console.log(`\nHYPE mark=$${hype.market.markPx}  spread=${hype.book.spreadBps?.toFixed(2)}bps  candles=${hype.candles.count}`);
+
+const spot = await desk.call("hl-markets", "spot", {});
+console.log(`spot: ${spot.tokenCount} tokens / ${spot.pairCount} pairs`);

package/scripts/e2e-hl-perps.mjs

@@ -0,0 +1,48 @@
+import { data as desk } from "../src/data/desk-data.mjs";
+
+const info = await desk.call("hl-perps", "assetInfo", { coin: "BTC" });
+console.log(`BTC assetId=${info.assetId} szDecimals=${info.szDecimals} maxLev=${info.maxLeverage}x mark=$${info.markPx}`);
+
+// 1. LIMIT BUY
+const lim = await desk.call("hl-perps", "prepareOrder", {
+  coin: "BTC", side: "buy", type: "limit", price: "60000.123456789", size: "0.0123456", tif: "Gtc",
+});
+console.log(`\nLIMIT BUY  px=${lim.price} sz=${lim.size} notional=$${lim.notionalUsd?.toFixed(2)} tif=${JSON.stringify(lim.action.orders[0].t)}`);
+console.log(`  signingReady=${lim.signingReady} broadcastReady=${lim.broadcastReady} requiresUserSig=${lim.requiresUserSignature}`);
+
+// 2. MARKET BUY with slippage cap
+const mkt = await desk.call("hl-perps", "prepareOrder", {
+  coin: "ETH", side: "buy", type: "market", size: "0.5", maxSlippageBps: 50,
+});
+console.log(`\nMARKET BUY ETH  aggressive px=${mkt.price} sz=${mkt.size} tif=${mkt.action.orders[0].t.limit.tif}`);
+
+// 3. slippage cap enforced
+try {
+  await desk.call("hl-perps", "prepareOrder", { coin: "ETH", side: "buy", type: "market", size: "1", maxSlippageBps: 500 });
+  console.log("  !! 500bps ACCEPTED — cap broken");
+} catch (e) { console.log(`  500bps rejected: ${e.message.slice(0, 60)}`); }
+
+// 4. LEVERAGE
+const lev = await desk.call("hl-perps", "prepareLeverage", { coin: "BTC", leverage: 25, marginMode: "isolated" });
+console.log(`\nLEVERAGE  ${lev.leverage}x ${lev.marginMode}  isCross=${lev.action.isCross}`);
+console.log(`  warning: ${lev.liquidationWarning}`);
+
+try {
+  await desk.call("hl-perps", "prepareLeverage", { coin: "BTC", leverage: 999 });
+  console.log("  !! 999x ACCEPTED — cap broken");
+} catch (e) { console.log(`  999x rejected: ${e.message.slice(0, 70)}`); }
+
+// 5. BRACKET: entry + TP + SL
+const br = await desk.call("hl-perps", "prepareBracket", {
+  coin: "BTC", side: "buy", type: "limit", price: "60000", size: "0.01",
+  takeProfitPx: "72000", stopLossPx: "57000",
+});
+console.log(`\nBRACKET  legs=${br.legs} entry=${br.entry.price} tp=${br.takeProfitPx} sl=${br.stopLossPx} grouping=${br.action.grouping}`);
+console.log(`  tp reduceOnly=${br.action.orders[1].r} trigger=${JSON.stringify(br.action.orders[1].t.trigger)}`);
+console.log(`  sl reduceOnly=${br.action.orders[2].r} trigger=${JSON.stringify(br.action.orders[2].t.trigger)}`);
+
+// 6. CANCEL
+const c = await desk.call("hl-perps", "prepareCancel", { coin: "BTC", orderId: 12345 });
+console.log(`\nCANCEL  oid=${c.orderId} action=${JSON.stringify(c.action)}`);
+
+console.log("\nNo submit function exists in hl-perps — every result is user-signed.");

package/scripts/e2e-hypercore-staking.mjs

@@ -0,0 +1,128 @@
+import { data as desk } from "../src/data/desk-data.mjs";
+import {
+  hlPrepareStakeDeposit,
+  hlPrepareStakeWithdraw,
+  hlPrepareDelegate,
+  hypeToWei,
+  weiToHype,
+} from "../src/data/providers/hl-staking.mjs";
+
+const USER = process.env.ORACLE_E2E_EVM_ADDRESS || "0x0000000000000000000000000000000000000001";
+const results = [];
+function log(lane, status, detail) {
+  results.push({ lane, status });
+  console.log(`${status === "ok" ? "OK  " : "FAIL"} ${lane} :: ${detail}`);
+}
+async function run(lane, fn) {
+  try {
+    log(lane, "ok", await fn());
+  } catch (e) {
+    log(lane, "fail", String(e?.message || e).slice(0, 150));
+  }
+}
+
+console.log("== HYPERCORE STAKING ==");
+
+let validator = null;
+await run("hl.staking.validators", async () => {
+  const v = await desk.hl.staking.validators();
+  const active = v.validators.filter((x) => x.isActive && !x.isJailed);
+  validator = active[0]?.validator || v.validators[0]?.validator;
+  return `validators=${v.count} activeUnjailed=${active.length} first=${(validator || "").slice(0, 10)}..`;
+});
+
+await run("hl.staking.health", async () => {
+  const h = await desk.hl.staking.health();
+  if (!h.ok) throw new Error("staking lane unhealthy");
+  return `ok validators=${h.validators} chain=${h.chain}`;
+});
+
+await run("hl.staking.delegatorSummary", async () => {
+  const s = await desk.hl.staking.summary(USER);
+  return `delegated=${s.delegatedWei} undelegated=${s.undelegatedWei} pendingWithdrawals=${s.nPendingWithdrawals}`;
+});
+
+await run("hl.staking.delegations", async () => {
+  const d = await desk.hl.staking.delegations(USER);
+  return `count=${d.count}`;
+});
+
+await run("hl.staking.rewards", async () => {
+  const r = await desk.hl.staking.rewards(USER);
+  return `rewards=${r.rewards.length}`;
+});
+
+await run("hl.staking.preflight", async () => {
+  const p = await desk.hl.staking.preflight(USER);
+  return `undelegated=${p.stakingBalanceUndelegated} queueDays=${p.unstakingQueueDays} lockupDays=${p.validatorLockupDays}`;
+});
+
+await run("hl.staking.units", async () => {
+  const w = hypeToWei("1.5");
+  if (w !== "150000000") throw new Error(`1.5 HYPE -> ${w}, expected 150000000`);
+  if (weiToHype("150000000") !== "1.5") throw new Error("roundtrip failed");
+  return `1.5 HYPE = ${w} wei roundtrip ok`;
+});
+
+await run("hl.staking.prepareStake", async () => {
+  const p = hlPrepareStakeDeposit({ amountHype: "2.5", maxHype: "10" });
+  if (p.action.type !== "cDeposit") throw new Error("wrong action type");
+  if (p.broadcastReady !== false || p.signingReady !== false) throw new Error("leaked readiness");
+  if (!p.requiresUserSignature) throw new Error("must require user signature");
+  return `cDeposit wei=${p.action.wei} primaryType=${p.typedData.primaryType} broadcastReady=false`;
+});
+
+await run("hl.staking.prepareStake.capBreach", async () => {
+  try {
+    hlPrepareStakeDeposit({ amountHype: "50", maxHype: "10" });
+  } catch (e) {
+    return `rejected over-cap: ${String(e.message).slice(0, 70)}`;
+  }
+  throw new Error("cap was NOT enforced");
+});
+
+await run("hl.staking.prepareDelegate", async () => {
+  if (!validator) throw new Error("no validator resolved");
+  const p = hlPrepareDelegate({ validator, amountHype: "2.5", isUndelegate: false, maxHype: "10" });
+  if (p.action.type !== "tokenDelegate" || p.action.isUndelegate !== false) throw new Error("wrong action");
+  return `tokenDelegate validator=${p.action.validator.slice(0, 10)}.. wei=${p.action.wei} isUndelegate=false`;
+});
+
+await run("hl.staking.prepareUndelegate", async () => {
+  const p = hlPrepareDelegate({ validator, amountHype: "2.5", isUndelegate: true });
+  if (p.action.isUndelegate !== true) throw new Error("undelegate flag lost");
+  return `tokenDelegate isUndelegate=true kind=${p.kind}`;
+});
+
+await run("hl.staking.prepareUnstake", async () => {
+  const p = hlPrepareStakeWithdraw({ amountHype: "2.5" });
+  if (p.action.type !== "cWithdraw") throw new Error("wrong action type");
+  if (!p.notes.join(" ").includes("7 day")) throw new Error("missing unstaking queue warning");
+  return `cWithdraw wei=${p.action.wei} queue warning present`;
+});
+
+await run("hl.staking.badAmount", async () => {
+  try {
+    hlPrepareStakeDeposit({ amountHype: "0" });
+  } catch (e) {
+    return `rejected zero amount`;
+  }
+  throw new Error("zero amount accepted");
+});
+
+await run("hl.staking.badValidator", async () => {
+  try {
+    hlPrepareDelegate({ validator: "not-an-address", amountHype: "1" });
+  } catch (e) {
+    return `rejected bad validator`;
+  }
+  throw new Error("bad validator accepted");
+});
+
+const failed = results.filter((r) => r.status === "fail");
+console.log(`\nlanes=${results.length} ok=${results.length - failed.length} failed=${failed.length}`);
+if (failed.length) {
+  console.log(`FAILED: ${failed.map((f) => f.lane).join(", ")}`);
+  process.exit(1);
+}
+console.log("HYPERCORE STAKING OK: reads live, stake/unstake/delegate prepare-only, caps enforced.");