hypow 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,1025 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { parseArgs } from "node:util";
+import { getAddress as getAddress3, isAddress as isAddress3, parseEther as parseEther2 } from "viem";
+
+// src/home.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { getAddress, isAddress, isHex } from "viem";
+import { generatePrivateKey } from "viem/accounts";
+var PUBLIC = "public";
+var home = () => process.env.HYPOW_HOME ?? join(homedir(), ".hypow", "mainnet");
+function write(name, value) {
+  mkdirSync(home(), { recursive: true, mode: 448 });
+  writeFileSync(join(home(), name), `${value}
+`, { mode: 384 });
+}
+function read(name) {
+  const path = join(home(), name);
+  return existsSync(path) ? readFileSync(path, "utf8").trim() : void 0;
+}
+function loadKey() {
+  const saved = read("key");
+  if (saved !== void 0) {
+    if (!isHex(saved) || saved.length !== 66) throw new Error(`${join(home(), "key")} is not a private key`);
+    return { key: saved, created: false };
+  }
+  const key = generatePrivateKey();
+  write("key", key);
+  return { key, created: true };
+}
+function loadOwner() {
+  const owner = read("owner");
+  return owner !== void 0 && isAddress(owner) ? getAddress(owner) : void 0;
+}
+function saveOwner(owner) {
+  write("owner", owner);
+}
+function loadRpc() {
+  const rpc = read("rpc");
+  return rpc === PUBLIC ? null : rpc;
+}
+function saveRpc(url) {
+  write("rpc", url ?? PUBLIC);
+}
+
+// src/log.ts
+import { styleText } from "node:util";
+var LABEL_STYLES = {
+  captured: "green",
+  ticket: "cyan",
+  error: "red",
+  lost: "red",
+  missed: "red",
+  "gas low": "yellow",
+  subaccounts: "yellow",
+  pooled: "yellow"
+};
+var BLOCK_STYLE = ["bold", "redBright"];
+var ALARM_STYLE = ["bold", "red"];
+var alarm = (label, message) => label.startsWith("\u26A0") || message.startsWith("\u26A0");
+function paint(style, text) {
+  return styleText(style, text, { stream: process.stdout });
+}
+function format(label, message) {
+  const time = paint("dim", (/* @__PURE__ */ new Date()).toTimeString().slice(0, 8));
+  const padded = label.padEnd(11);
+  if (label.startsWith("BLOCK")) return `${time}  ${paint(BLOCK_STYLE, `${padded} ${message}`)}`;
+  if (alarm(label, message)) return `${time}  ${paint(ALARM_STYLE, `${padded} ${message}`)}`;
+  const cut = message.indexOf(" \xB7 ");
+  const body = cut < 0 ? message : `${message.slice(0, cut)}${paint("dim", message.slice(cut))}`;
+  return `${time}  ${paint(LABEL_STYLES[label] ?? "dim", padded)} ${body}`;
+}
+function line(label, message) {
+  console.log(format(label, message));
+}
+
+// src/mine.ts
+import { extname } from "node:path";
+import { Worker } from "node:worker_threads";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+
+// src/authorize.ts
+import { spawn } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { readFileSync as readFileSync2 } from "node:fs";
+import { createServer } from "node:http";
+import { setTimeout as sleep2 } from "node:timers/promises";
+import { encodeFunctionData, getAddress as getAddress2, isAddress as isAddress2, isHex as isHex2 } from "viem";
+
+// src/chain.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  decodeAbiParameters,
+  defineChain,
+  encodeAbiParameters,
+  fallback,
+  http,
+  parseAbi,
+  parseEventLogs
+} from "viem";
+import { nonceManager, privateKeyToAccount } from "viem/accounts";
+var minterAbi = parseAbi([
+  "function capture(address member, uint32[] assets) returns (uint128 k)",
+  "function spend(address owner, uint128 maxK) returns (uint64 round, uint128 k)",
+  "function settle(address owner, uint64 round, bytes signature, uint256 nonce) returns (uint256 reward)",
+  "function setSpender(address newSpender)",
+  "function setSpenderBySig(address owner, address newSpender, uint256 nonce, uint256 deadline, bytes signature)",
+  "function nonces(address) view returns (uint256)",
+  "function spender(address) view returns (address)",
+  "function creditDelegate(address) view returns (address)",
+  "function credits(address) view returns (uint128)",
+  "function draws(address, uint64) view returns (uint128)",
+  "function memberSlots(address, uint32) view returns (int64 lastSnapshotSzi, bool known, uint64 lastMarkPx)",
+  "function memberAssetsLength(address member) view returns (uint256)",
+  "function memberAssets(address member, uint256 index) view returns (uint32)",
+  "function token() view returns (address)",
+  "function difficulty() view returns (uint128)",
+  "function winCount() view returns (uint64)",
+  "function lastWonRound() view returns (uint64)",
+  "function wonBy(uint64 round) view returns (address owner, uint128 difficulty, uint128 reward)",
+  "event AssetRegistered(address indexed member, uint32 indexed asset, int64 baselineSzi)",
+  "event Captured(address indexed member, address indexed destination, uint128 cents)",
+  "event Spent(address indexed owner, uint64 indexed round, uint128 k, uint128 drawK)",
+  "event Won(address indexed owner, uint64 indexed round, uint64 indexed winCount, uint256 nonce, uint256 reward, address caller)"
+]);
+var MULTICALL3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
+function clients(net, rpc) {
+  const own = rpc ? [rpc] : [];
+  const rpcs = [...own, ...net.rpcs];
+  const chain = defineChain({
+    id: net.chainId,
+    name: net.name,
+    nativeCurrency: { name: "HYPE", symbol: "HYPE", decimals: 18 },
+    rpcUrls: { default: { http: rpcs } },
+    contracts: { multicall3: { address: MULTICALL3 } }
+  });
+  const transport = fallback(rpcs.map((url) => http(url)));
+  return {
+    chain,
+    transport,
+    /** Whether the user's own RPC comes first. */
+    own: rpc !== void 0,
+    /** Host only: the path of a keyed RPC carries its API key. */
+    rpcHost: new URL(rpcs[0]).host,
+    read: createPublicClient({ chain, transport, batch: { multicall: true } }),
+    logs: createPublicClient({ chain, transport: fallback([...own, ...net.logRpcs].map((url) => http(url))) })
+  };
+}
+function connect(net, key, rpc) {
+  const { chain, transport, own, rpcHost, read: read2, logs } = clients(net, rpc);
+  const account = privateKeyToAccount(key, { nonceManager });
+  return { net, account, own, rpcHost, read: read2, logs, write: createWalletClient({ chain, transport, account }) };
+}
+async function setSpenderBySig(c, auth) {
+  const hash = await c.write.writeContract({
+    address: c.net.minter,
+    abi: minterAbi,
+    functionName: "setSpenderBySig",
+    args: [auth.owner, c.account.address, auth.nonce, auth.deadline, auth.signature]
+  });
+  const receipt = await c.read.waitForTransactionReceipt({ hash });
+  if (receipt.status !== "success") throw new Error(`the authorization failed \xB7 tx ${hash}`);
+  return hash;
+}
+var POSITION2 = "0x0000000000000000000000000000000000000813";
+async function l1Szi(c, owner, asset) {
+  const { data } = await c.read.call({
+    to: POSITION2,
+    data: encodeAbiParameters([{ type: "address" }, { type: "uint32" }], [owner, asset])
+  });
+  if (!data) throw new Error("position2 returned nothing");
+  return decodeAbiParameters([{ type: "int64" }], data)[0];
+}
+function padGas(estimate) {
+  return estimate * 3n / 2n;
+}
+async function transact(c, functionName, args) {
+  const call = { address: c.net.minter, abi: minterAbi, functionName, args };
+  const estimate = await c.read.estimateContractGas({ ...call, account: c.account, prepare: false });
+  const hash = await c.write.writeContract({ ...call, gas: padGas(estimate) });
+  const receipt = await c.read.waitForTransactionReceipt({ hash, checkReplacement: false });
+  if (receipt.status !== "success") throw new Error(`${functionName} reverted \xB7 tx ${hash}`);
+  return { hash, events: parseEventLogs({ abi: minterAbi, logs: receipt.logs }) };
+}
+
+// src/core.ts
+import { isAddressEqual, zeroAddress } from "viem";
+
+// src/coalesce.ts
+function coalesce(run2) {
+  let running = false;
+  let queued = false;
+  const loop = async () => {
+    running = true;
+    do {
+      queued = false;
+      await run2();
+    } while (queued);
+    running = false;
+  };
+  return () => {
+    if (running) queued = true;
+    else void loop();
+  };
+}
+
+// src/hyperliquid.ts
+import { parseUnits } from "viem";
+async function info(url, body) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!res.ok) throw new Error(`Hyperliquid info ${JSON.stringify(body)}: HTTP ${res.status}`);
+  return await res.json();
+}
+function perps(metas) {
+  return metas.flatMap((meta, dex) => meta.universe.map(({ name, szDecimals }, i) => ({ name, szDecimals, asset: dex * 1e4 + i })));
+}
+async function perpUniverse(url) {
+  return perps(await info(url, { type: "allPerpMetas" }));
+}
+function heldIn(data) {
+  return data.clearinghouseStates.flatMap(
+    ([, state]) => state.assetPositions.filter((p) => Number(p.position.szi) !== 0).map((p) => p.position.coin)
+  );
+}
+function heldCoins(wsUrl, user) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(wsUrl);
+    const fail = (why) => {
+      clearTimeout(timer);
+      ws.close();
+      reject(new Error(`Hyperliquid positions: ${why}`));
+    };
+    const timer = setTimeout(() => fail("no answer in 10s"), 1e4);
+    ws.addEventListener(
+      "open",
+      () => ws.send(JSON.stringify({ method: "subscribe", subscription: { type: "allDexsClearinghouseState", user } }))
+    );
+    ws.addEventListener("message", (e) => {
+      const msg = JSON.parse(String(e.data));
+      if (msg.channel !== "allDexsClearinghouseState") return;
+      clearTimeout(timer);
+      ws.close();
+      resolve(heldIn(msg.data));
+    });
+    ws.addEventListener("error", () => fail("websocket error"));
+  });
+}
+async function subAccountNames(url, user) {
+  const subs = await info(url, { type: "subAccounts", user });
+  return (subs ?? []).map((s) => s.name);
+}
+function fillsAfter(url, user, time) {
+  return info(url, { type: "userFillsByTime", user, startTime: time + 1 });
+}
+function sziAfter(f, szDecimals) {
+  const sz = parseUnits(f.sz, szDecimals);
+  return parseUnits(f.startPosition, szDecimals) + (f.side === "B" ? sz : -sz);
+}
+function watchFills(url, user, onFills, signal) {
+  if (signal.aborted) return;
+  const ws = new WebSocket(url);
+  const stop = () => ws.close();
+  signal.addEventListener("abort", stop, { once: true });
+  let ping;
+  ws.addEventListener("open", () => {
+    ws.send(JSON.stringify({ method: "subscribe", subscription: { type: "userFills", user } }));
+    ping = setInterval(() => ws.send(JSON.stringify({ method: "ping" })), 5e4);
+  });
+  ws.addEventListener("message", (e) => {
+    const msg = JSON.parse(String(e.data));
+    if (msg.channel === "userFills" && !msg.data.isSnapshot) onFills(msg.data.fills);
+  });
+  ws.addEventListener("close", () => {
+    clearInterval(ping);
+    signal.removeEventListener("abort", stop);
+    setTimeout(() => watchFills(url, user, onFills, signal), 2e3);
+  });
+}
+
+// src/protocol.ts
+import { keccak_256 } from "@noble/hashes/sha3.js";
+import { bytesToHex, hexToBytes } from "viem";
+var DRAND_GENESIS = 1727521075;
+var DRAND_PERIOD = 3;
+var DRAND_URL = "https://api.drand.sh/v2/beacons/evmnet/rounds/";
+function publishTime(round) {
+  return DRAND_GENESIS + (round - 1) * DRAND_PERIOD;
+}
+var ROUND_LEAD = 2;
+function openDrawsSince(lastWon) {
+  return publishTime(Number(lastWon) + 1 - ROUND_LEAD);
+}
+function ticketSize(difficulty2, bank) {
+  const ceilDiv = (a, b) => (a + b - 1n) / b;
+  const cap = ceilDiv(difficulty2, 10n);
+  const floor = ceilDiv(bank, 20n);
+  const size = cap > floor ? cap : floor;
+  return size < bank ? size : bank;
+}
+function parseDrand(body, round) {
+  const { round: got, signature } = body;
+  if (got !== round) throw new Error(`drand returned round ${String(got)}, wanted ${round}`);
+  if (typeof signature !== "string" || !/^[0-9a-f]{128}$/i.test(signature)) {
+    throw new Error("drand signature is not 64 bytes of hex");
+  }
+  return `0x${signature.toLowerCase()}`;
+}
+async function fetchDrand(round) {
+  const res = await fetch(DRAND_URL + round);
+  if (!res.ok) throw new Error(`drand round ${round}: HTTP ${res.status}`);
+  return parseDrand(await res.json(), round);
+}
+function seedOf(signature) {
+  return keccak_256(hexToBytes(signature));
+}
+function targetOf(difficulty2) {
+  return hexToBytes(`0x${((2n ** 256n - 1n) / difficulty2).toString(16).padStart(64, "0")}`);
+}
+
+// src/network.ts
+import { parseEther } from "viem";
+
+// src/text.ts
+import { formatEther } from "viem";
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function short(hex) {
+  return `${hex.slice(0, 6)}\u2026${hex.slice(-4)}`;
+}
+function count(n) {
+  return n.toLocaleString("en-US");
+}
+function amount(wei) {
+  return Number(formatEther(wei)).toLocaleString("en-US", {
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2
+  });
+}
+function hype(wei) {
+  return Number(formatEther(wei)).toLocaleString("en-US", { maximumFractionDigits: 4 });
+}
+function describe(err) {
+  if (process.env.DEBUG === "1") console.error(err);
+  const e = err;
+  const msg = (e.shortMessage ?? e.message ?? String(err)).replace(/\s+/g, " ").trim();
+  return e.cause?.code ? `${msg} (${e.cause.code})` : msg;
+}
+async function retrying(line2, fn, delayMs) {
+  for (; ; ) {
+    try {
+      return await fn();
+    } catch (err) {
+      line2("error", `${describe(err)} \xB7 retrying in ${delayMs / 1e3}s`, err);
+      await sleep(delayMs);
+    }
+  }
+}
+
+// src/network.ts
+function covers(net, gas) {
+  return `it pays the fees for about ${count(gas / net.ticketFee)} tickets`;
+}
+var MAINNET = {
+  name: "HyperEVM mainnet",
+  chainId: 999,
+  minter: "0x14ae637542b6a125217ee477b756504ff009d506",
+  deployBlock: 47234006n,
+  rpcs: [
+    "https://rpc.hyperliquid.xyz/evm",
+    "https://hyperliquid-json-rpc.stakely.io",
+    "https://rpc.hypurrscan.io",
+    "https://hyperliquid.drpc.org"
+  ],
+  logRpcs: ["https://rpc.hyperliquid.xyz/evm", "https://hyperliquid-json-rpc.stakely.io", "https://rpc.hypurrscan.io"],
+  walletRpc: "https://rpc.hyperliquid.xyz/evm",
+  hyperliquidInfo: "https://api.hyperliquid.xyz/info",
+  hyperliquidWs: "wss://api.hyperliquid.xyz/ws",
+  gasFund: parseEther("0.01"),
+  minGas: parseEther("0.0005"),
+  // Measured in the mainnet rehearsal at 0.1 gwei: spend ~77k gas plus cash ~264k is ~3.4e-5 HYPE. Rounded up.
+  ticketFee: parseEther("0.00005"),
+  starterCoins: ["BTC", "ETH", "SOL", "HYPE"]
+};
+
+// src/core.ts
+var RETRY_MS = 5e3;
+var BACKSTOP_MS = 6e4;
+var L1READ_POLL_MS = 1e3;
+var L1READ_CAP_MS = 15e3;
+var MAX_U128 = 2n ** 128n - 1n;
+var LOG_CHUNK = 1000n;
+var GAS_POLL_MS = 5e3;
+async function status(c, owner) {
+  const [spender, balance] = await Promise.all([
+    c.read.readContract({ address: c.net.minter, abi: minterAbi, functionName: "spender", args: [owner] }),
+    c.read.getBalance({ address: c.account.address })
+  ]);
+  return { spender: spender === c.account.address, gas: balance >= c.net.minGas, balance };
+}
+var ready = (s) => s.spender && s.gas;
+async function untilFunded(balance, min, pollMs, signal, report) {
+  let b = await balance();
+  if (b >= min) return true;
+  report.low(b);
+  while (b < min) {
+    if (signal.aborted) return false;
+    await sleep(pollMs);
+    b = await balance();
+  }
+  report.funded(b);
+  return !signal.aborted;
+}
+var perpNamed = (universe, coin) => universe.find((p) => p.name === coin);
+var nameOf = (universe, asset) => universe.find((p) => p.asset === asset)?.name ?? `asset ${asset}`;
+async function run(c, owner, p, signal) {
+  const { line: line2 } = p;
+  const key = c.account.address;
+  const funded = () => untilFunded(() => c.read.getBalance({ address: key }), c.net.minGas, GAS_POLL_MS, signal, {
+    low: (b) => {
+      line2("gas low", `the miner key holds ${hype(b)} HYPE, too little for fees \xB7 mining paused`);
+      line2("", `send ${hype(c.net.gasFund)} HYPE to ${key} on ${c.net.name} \xB7 ${covers(c.net, c.net.gasFund)} \xB7 mining resumes once it lands`);
+      p.gas(true);
+    },
+    funded: (b) => {
+      line2("funded", `the miner key holds ${hype(b)} HYPE for fees \xB7 mining again`);
+      p.gas(false);
+    }
+  });
+  if (!await retrying(line2, funded, RETRY_MS)) return;
+  const pool = await retrying(line2, () => poolOf(c, owner), RETRY_MS);
+  if (pool !== zeroAddress) {
+    line2("pooled", `${short(owner)} has joined the pool ${short(pool)} \xB7 its trades earn for the pool, and only the pool can capture them`);
+    line2("", "this miner mines solo \xB7 to mine here, leave the pool by calling setCreditDelegate(0x0) on the minter, then start again");
+    return;
+  }
+  const subs = await retrying(line2, () => subAccountNames(c.net.hyperliquidInfo, owner), RETRY_MS);
+  if (subs.length > 0) {
+    line2("subaccounts", `your subaccounts ${subs.join(", ")} don't mine \xB7 only trades on this main account mine, not on subaccounts or vaults`);
+  }
+  const m = {
+    c,
+    owner,
+    universe: await retrying(line2, () => perpUniverse(c.net.hyperliquidInfo), RETRY_MS),
+    p,
+    signal,
+    funded
+  };
+  await retrying(line2, () => register(m), RETRY_MS);
+  await retrying(line2, () => resume(m), RETRY_MS);
+  if (signal.aborted) return;
+  const fills = /* @__PURE__ */ new Map();
+  const state = { idle: false, fills };
+  let latest = Promise.resolve();
+  const pass = coalesce(
+    () => latest = (async () => {
+      if (signal.aborted) return;
+      const targets = new Map(fills);
+      fills.clear();
+      try {
+        const held = heldCoins(c.net.hyperliquidWs, owner);
+        held.catch(() => {
+        });
+        if (!await reflected(m, targets)) setTimeout(pass, BACKSTOP_MS);
+        await tick(m, state, await held);
+      } catch (err) {
+        line2("error", `${describe(err)} \xB7 retrying in ${RETRY_MS / 1e3}s`, err);
+        setTimeout(pass, RETRY_MS);
+      }
+      p.refresh();
+    })()
+  );
+  let seen = Date.now();
+  const onFills = (batch) => {
+    for (const f of batch) {
+      seen = Math.max(seen, f.time);
+      const perp = perpNamed(m.universe, f.coin);
+      if (!perp) continue;
+      fills.set(perp, sziAfter(f, perp.szDecimals));
+      line2("trade", `${f.side === "B" ? "bought" : "sold"} ${f.sz} ${f.coin}`);
+    }
+    pass();
+  };
+  watchFills(c.net.hyperliquidWs, owner, onFills, signal);
+  const backstop = setInterval(async () => {
+    try {
+      const missed = (await fillsAfter(c.net.hyperliquidInfo, owner, seen)).filter((f) => f.time > seen);
+      if (missed.length > 0 && !signal.aborted) onFills(missed);
+    } catch (err) {
+      line2("error", `${describe(err)} \xB7 asking again in ${BACKSTOP_MS / 1e3}s`, err);
+    }
+  }, BACKSTOP_MS);
+  pass();
+  await new Promise((resolve) => signal.addEventListener("abort", resolve, { once: true }));
+  clearInterval(backstop);
+  for (let last; last !== latest; ) await (last = latest);
+}
+async function reflected({ c, owner, p }, targets) {
+  const deadline = Date.now() + L1READ_CAP_MS;
+  for (const [perp, szi] of targets) {
+    while (await l1Szi(c, owner, perp.asset) !== szi) {
+      if (Date.now() > deadline) {
+        p.line("lagging", `HyperEVM doesn't show your ${perp.name} fill after ${L1READ_CAP_MS / 1e3}s \xB7 capturing anyway, and again in ${BACKSTOP_MS / 1e3}s`);
+        return false;
+      }
+      await sleep(L1READ_POLL_MS);
+    }
+  }
+  return true;
+}
+async function register({ c, owner, universe, p }) {
+  const held = await heldCoins(c.net.hyperliquidWs, owner);
+  const coins = [.../* @__PURE__ */ new Set([...held, ...c.net.starterCoins])];
+  const known = coins.map((coin) => perpNamed(universe, coin)).filter((perp) => perp !== void 0);
+  const slots = await Promise.all(
+    known.map(
+      (perp) => c.read.readContract({
+        address: c.net.minter,
+        abi: minterAbi,
+        functionName: "memberSlots",
+        args: [owner, perp.asset]
+      })
+    )
+  );
+  const fresh = known.filter((_, i) => !slots[i][1]);
+  if (fresh.length === 0) return;
+  await transact(c, "capture", [owner, fresh.map((perp) => perp.asset)]);
+  p.line("registered", `registered ${fresh.map((perp) => perp.name).join(" ")} \xB7 your current positions are the starting point`);
+  p.line("", "only trading from now on earns attempts");
+}
+async function resume(m) {
+  for (const [round, k] of await openDraws(m.c, m.owner, m.p.line, RETRY_MS)) {
+    m.p.line("resuming", `resuming a ticket of ${count(k)} attempts on round ${round}`);
+    await draw(m, round, k);
+  }
+}
+async function openDraws(c, owner, line2, retryMs) {
+  const [head, lastWon] = await Promise.all([c.logs.getBlockNumber(), lastWonRound(c)]);
+  const timestamp = async (n) => (await c.read.getBlock({ blockNumber: n })).timestamp;
+  const start = await firstBlockAt(timestamp, c.net.deployBlock, head, BigInt(openDrawsSince(lastWon)));
+  const rounds = /* @__PURE__ */ new Set();
+  for (let from = start; from <= head; from += LOG_CHUNK) {
+    const to = from + LOG_CHUNK - 1n < head ? from + LOG_CHUNK - 1n : head;
+    const logs = await retrying(
+      line2,
+      () => c.logs.getContractEvents({ address: c.net.minter, abi: minterAbi, eventName: "Spent", args: { owner }, fromBlock: from, toBlock: to }),
+      retryMs
+    );
+    for (const log of logs) if (log.args.round > lastWon) rounds.add(log.args.round);
+  }
+  const open = /* @__PURE__ */ new Map();
+  for (const round of rounds) {
+    const k = await c.read.readContract({ address: c.net.minter, abi: minterAbi, functionName: "draws", args: [owner, round] });
+    if (k > 0n) open.set(round, k);
+  }
+  return open;
+}
+async function firstBlockAt(timestamp, from, head, since) {
+  let [lo, hi] = [from, head];
+  while (lo < hi) {
+    const mid = (lo + hi) / 2n;
+    if (await timestamp(mid) >= since) hi = mid;
+    else lo = mid + 1n;
+  }
+  return lo;
+}
+async function tick(m, state, held) {
+  const { c, owner, universe, p, signal } = m;
+  if (!await m.funded()) return;
+  const tracked = await trackedAssets(c, owner);
+  const opens = held.map((coin) => perpNamed(universe, coin)?.asset).filter((a) => a !== void 0 && !tracked.includes(a));
+  if (opens.length > 0) {
+    const { events } = await transact(c, "capture", [owner, opens]);
+    for (const e of events) {
+      if (e.eventName === "AssetRegistered") p.line("registered", `registered ${nameOf(universe, e.args.asset)} \xB7 your current position is the starting point`);
+      if (e.eventName === "Captured") p.line("captured", `+${count(e.args.cents)} attempts`);
+    }
+  }
+  while (!signal.aborted) {
+    const { result } = await c.read.simulateContract({
+      address: c.net.minter,
+      abi: minterAbi,
+      functionName: "spend",
+      args: [owner, MAX_U128],
+      account: c.account
+    });
+    const bank = result[1];
+    if (bank === 0n) break;
+    state.idle = false;
+    for (let left = bank; left > 0n; ) {
+      if (signal.aborted || state.fills.size > 0 || !await m.funded()) return;
+      const { events } = await transact(c, "spend", [owner, ticketSize(await difficulty(c), bank)]);
+      for (const e of events) if (e.eventName === "Captured") p.line("captured", `+${count(e.args.cents)} attempts`);
+      const spent = events.find((e) => e.eventName === "Spent");
+      if (!spent) {
+        p.line("missed", "that trade closed before HyperEVM captured it \xB7 nothing to play");
+        return;
+      }
+      left -= spent.args.k;
+      const drawsIn = Math.max(0, Math.ceil(publishTime(Number(spent.args.round)) - Date.now() / 1e3));
+      p.line("ticket", `${count(spent.args.k)} attempts \u2192 round ${spent.args.round} \xB7 draws in ${drawsIn}s`);
+      p.refresh();
+      await draw(m, spent.args.round, spent.args.drawK);
+    }
+  }
+  if (signal.aborted) return;
+  if (!state.idle) p.line("waiting", "waiting for your next trade on Hyperliquid");
+  state.idle = true;
+}
+async function draw(m, round, k) {
+  const wait = publishTime(Number(round)) * 1e3 - Date.now();
+  if (wait > 0) await sleep(wait + 500);
+  const signature = await retrying(m.p.line, () => fetchDrand(Number(round)), 2e3);
+  await retrying(m.p.line, () => cash(m, round, k, signature), RETRY_MS);
+}
+async function cash({ c, owner, p }, round, k, signature) {
+  const d = await difficulty(c);
+  p.line("drawn", `round ${round} drawn \xB7 searching ${count(k)} attempts at difficulty ${count(d)}`);
+  const nonce = await p.search(seedOf(signature), owner, Number(k), targetOf(d));
+  if (nonce === 0) {
+    p.line("searching", `searched ${count(k)}/${count(k)} \xB7 no win`);
+    return;
+  }
+  p.line("searching", `attempt ${count(nonce)}/${count(k)} wins \xB7 cashing it`);
+  if (await lastWonRound(c) >= round) {
+    const [winner, , reward] = await c.read.readContract({ address: c.net.minter, abi: minterAbi, functionName: "wonBy", args: [round] });
+    if (!isAddressEqual(winner, owner)) return p.line("lost", "someone else found this block first");
+    p.won();
+    return p.line("BLOCK", `found on round ${round} \xB7 +${amount(reward)} HYPOW \u2192 ${short(owner)}`);
+  }
+  const { hash, events } = await transact(c, "settle", [owner, round, signature, BigInt(nonce)]);
+  const won = events.find((e) => e.eventName === "Won");
+  if (!won) throw new Error("settle emitted no win");
+  p.won();
+  p.line(`BLOCK ${won.args.winCount + 1n}`, `found on round ${round} \xB7 +${amount(won.args.reward)} HYPOW \u2192 ${short(owner)} \xB7 tx ${short(hash)}`);
+}
+function poolOf(c, owner) {
+  return c.read.readContract({ address: c.net.minter, abi: minterAbi, functionName: "creditDelegate", args: [owner] });
+}
+async function difficulty(c) {
+  return c.read.readContract({ address: c.net.minter, abi: minterAbi, functionName: "difficulty" });
+}
+async function lastWonRound(c) {
+  return c.read.readContract({ address: c.net.minter, abi: minterAbi, functionName: "lastWonRound" });
+}
+async function trackedAssets(c, owner) {
+  const n = await c.read.readContract({
+    address: c.net.minter,
+    abi: minterAbi,
+    functionName: "memberAssetsLength",
+    args: [owner]
+  });
+  return Promise.all(
+    Array.from(
+      { length: Number(n) },
+      (_, i) => c.read.readContract({
+        address: c.net.minter,
+        abi: minterAbi,
+        functionName: "memberAssets",
+        args: [owner, BigInt(i)]
+      })
+    )
+  );
+}
+
+// src/authorize.ts
+var PORT = 4747;
+async function waitForChain(c, owner) {
+  for (; ; ) {
+    const s = await retrying(line, () => status(c, owner), 3e3);
+    if (ready(s)) return s;
+    await sleep2(3e3);
+  }
+}
+async function authorize(c, opts) {
+  if (opts.owner) {
+    const given = opts.owner;
+    const s = await retrying(line, () => status(c, given), 3e3);
+    if (ready(s)) return { owner: opts.owner, status: s };
+    if (s.spender) line("gas low", `miner key has ${hype(s.balance)} HYPE, needs ${hype(c.net.minGas)} \xB7 top it up to keep mining`);
+    if (opts.manual) {
+      printManual(c, opts.owner, s, opts.gas);
+      return { owner: opts.owner, status: await waitForChain(c, opts.owner) };
+    }
+  }
+  return viaPage(c, opts.gas, opts.browser);
+}
+function printManual(c, owner, s, gas) {
+  const key = c.account.address;
+  line("authorize", `authorize this key from ${owner} on ${c.net.name} (chain ${c.net.chainId}):`);
+  if (!s.spender) {
+    line("", `\xB7 call setSpender(${key}) on the minter ${c.net.minter}`);
+    line("", `  (calldata ${setSpenderData(key)})`);
+  }
+  if (!s.gas) line("", `\xB7 send ${hype(gas)} HYPE to ${key} \xB7 ${covers(c.net, gas)}`);
+  line("waiting", "waiting for both to land on chain\u2026");
+}
+function setSpenderData(key) {
+  return encodeFunctionData({ abi: minterAbi, functionName: "setSpender", args: [key] });
+}
+async function readJson(req) {
+  let body = "";
+  for await (const chunk of req) body += chunk;
+  return JSON.parse(body);
+}
+function page(file) {
+  return readFileSync2(new URL(`../dist/${file}`, import.meta.url), "utf8");
+}
+async function viaPage(c, gas, browser) {
+  const token = randomBytes(16).toString("hex");
+  const config = { token, key: c.account.address, gas: gas.toString() };
+  const html = page("cli.html").replace("/*CONFIG*/", JSON.stringify(config));
+  const script = page("hypow-miner.js");
+  let owner;
+  let latest;
+  const server = createServer(async (req, res) => {
+    const json = (code, body) => {
+      res.writeHead(code, { "content-type": "application/json" });
+      res.end(JSON.stringify(body, (_, v) => typeof v === "bigint" ? v.toString() : v));
+    };
+    try {
+      if (req.method === "GET" && req.url === "/") {
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        res.end(html);
+        return;
+      }
+      if (req.method === "GET" && req.url === "/hypow-miner.js") {
+        res.writeHead(200, { "content-type": "text/javascript; charset=utf-8" });
+        res.end(script);
+        return;
+      }
+      if (req.headers["x-hypow-token"] !== token) return json(403, { error: "bad token" });
+      if (req.method === "POST" && req.url === "/owner") {
+        const { owner: posted } = await readJson(req);
+        if (!posted || !isAddress2(posted)) return json(400, { error: "not an address" });
+        owner = getAddress2(posted);
+        latest = await status(c, owner);
+        line("owner", `${short(owner)} connected \xB7 waiting for the chain\u2026`);
+        return json(200, latest);
+      }
+      if (req.method === "POST" && req.url === "/spender") {
+        const auth = await readJson(req);
+        if (!isAddress2(auth.owner) || !isHex2(auth.signature)) return json(400, { error: "not a SetSpender signature" });
+        const hash = await setSpenderBySig(c, {
+          owner: getAddress2(auth.owner),
+          nonce: BigInt(auth.nonce),
+          deadline: BigInt(auth.deadline),
+          signature: auth.signature
+        });
+        line("authorized", `${short(auth.owner)} signed \xB7 the key submitted it \xB7 tx ${short(hash)}`);
+        return json(200, { hash });
+      }
+      if (req.method === "GET" && req.url === "/status") return json(200, latest ?? null);
+      json(404, { error: "not found" });
+    } catch (err) {
+      json(500, { error: describe(err) });
+    }
+  });
+  await new Promise((resolve, reject) => {
+    server.once(
+      "error",
+      (err) => reject(
+        // The usual holder is another miner waiting at this same step. Two
+        // miners for one owner would take the authorization from each other.
+        err.code === "EADDRINUSE" ? new Error(`port ${PORT} is taken, most likely by another hypow miner on this machine \xB7 stop it, then run this again`) : err
+      )
+    );
+    server.listen(PORT, "127.0.0.1", resolve);
+  });
+  const url = `http://localhost:${PORT}`;
+  line("authorize", browser ? `${url} \u2014 opening browser\u2026` : `open ${url} in the browser that has your wallet`);
+  if (browser) openBrowser(url);
+  let done;
+  while (!done) {
+    await sleep2(2e3);
+    const polled = owner;
+    if (!polled) continue;
+    latest = await retrying(line, () => status(c, polled), 3e3);
+    if (ready(latest)) done = { owner: polled, status: latest };
+  }
+  await sleep2(4e3);
+  server.close();
+  return done;
+}
+function openBrowser(url) {
+  const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", ["/c", "start", "", url]] : ["xdg-open", [url]];
+  spawn(cmd, args, { detached: true, stdio: "ignore" }).on("error", () => {
+  }).unref();
+}
+
+// src/endpoint.ts
+import { createPublicClient as createPublicClient2, http as http2 } from "viem";
+var wantsPublic = (answer) => answer === "" || answer.toLowerCase() === "public";
+async function rpcProblem(net, url) {
+  if (!URL.canParse(url) || !/^https?:$/.test(new URL(url).protocol)) return "not an http(s) URL";
+  try {
+    const id = await createPublicClient2({ transport: http2(url, { timeout: 1e4, retryCount: 0 }) }).getChainId();
+    return id === net.chainId ? void 0 : `it serves chain ${id}, not ${net.name} (chain ${net.chainId})`;
+  } catch {
+    return "can't reach it";
+  }
+}
+var RATE_LIMITED = /rate.?limit|exceeds defined limit|too many requests/i;
+function rateLimited(err) {
+  for (let e = err; e; e = e.cause) {
+    if ([e.code, e.status, e.data?.code].some((c) => c === -32005 || c === 429)) return true;
+    if (RATE_LIMITED.test(`${e.message ?? ""} ${e.details ?? ""} ${e.data?.message ?? ""}`)) return true;
+  }
+  return false;
+}
+function rpcRow(c, fix) {
+  return ["rpc", c.own ? `your own \xB7 ${c.rpcHost}` : `\u26A0 using the rate-limited public RPC \xB7 trading often may miss blocks \xB7 to set your own RPC: ${fix}`];
+}
+var RATE_LIMIT_NOTE_MS = 18e4;
+function explainRateLimits(line2, own, fix, now = Date.now) {
+  let last = -Infinity;
+  return (label, message, cause) => {
+    line2(label, message, cause);
+    if (!rateLimited(cause) || now() - last < RATE_LIMIT_NOTE_MS) return;
+    last = now();
+    if (own) line2("rpc", "your own RPC rate-limited you \xB7 the miner retries until it answers again");
+    else line2("\u26A0 rpc", `the public RPC rate-limited you \xB7 mining paused about a minute \xB7 set your own with ${fix}`);
+  };
+}
+
+// src/rpc.ts
+import { stdin, stdout } from "node:process";
+import { createInterface } from "node:readline/promises";
+async function chooseRpc(net, flag) {
+  if (flag !== void 0) {
+    const p = await rpcProblem(net, flag);
+    if (p) throw new Error(`--rpc: ${p}`);
+    saveRpc(flag);
+    return flag;
+  }
+  const saved = loadRpc();
+  if (saved !== void 0) return saved ?? void 0;
+  if (!stdin.isTTY) return void 0;
+  line("rpc", "paste your HyperEVM RPC URL \xB7 a free one from Alchemy, QuickNode, \u2026 \xB7 asked once, change it later with --rpc");
+  const rl = createInterface({ input: stdin, output: stdout });
+  try {
+    for (; ; ) {
+      const answer = (await rl.question("HyperEVM RPC URL (Enter for the rate-limited public one): ")).trim();
+      const url = wantsPublic(answer) ? void 0 : answer;
+      const p = url && await rpcProblem(net, url);
+      if (p) {
+        line("rpc", `${p} \xB7 try again`);
+        continue;
+      }
+      saveRpc(url ?? null);
+      return url;
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+// src/status.ts
+import { constants } from "node:os";
+
+// src/standing.ts
+import { erc20Abi } from "viem";
+async function statusRows(c, token, owner, found) {
+  const minter = { address: c.net.minter, abi: minterAbi };
+  const [hypow, saved, gas, difficulty2, height] = await Promise.all([
+    c.read.readContract({ address: token, abi: erc20Abi, functionName: "balanceOf", args: [owner] }),
+    c.read.readContract({ ...minter, functionName: "credits", args: [owner] }),
+    c.read.getBalance({ address: c.account.address }),
+    c.read.readContract({ ...minter, functionName: "difficulty" }),
+    c.read.readContract({ ...minter, functionName: "winCount" })
+  ]);
+  return [
+    ["wallet", `${amount(hypow)} HYPOW \xB7 ${count(saved)} attempts saved`],
+    ["session", `${found} block${found === 1 ? "" : "s"} found`],
+    ["gas", `${hype(gas)} HYPE in the miner key \xB7 pays mining fees`],
+    ["network", `block ${count(height)} \xB7 difficulty ${count(difficulty2)}`]
+  ];
+}
+
+// src/status.ts
+var REFRESH_MS = 6e4;
+var RPC_FIX = "--rpc <url>";
+var LABEL_WIDTH = 9;
+var CSI = "\x1B[";
+var SAVE = "\x1B7";
+var RESTORE = "\x1B8";
+function render(rows, columns) {
+  const inner = Math.max(10, Math.min(columns - 4, Math.max(...rows.map(([, v]) => LABEL_WIDTH + v.length))));
+  const rule = "\u2500".repeat(inner + 2);
+  const body = rows.map(([label, value]) => {
+    const text = `${label.padEnd(LABEL_WIDTH)}${value}`;
+    const fit = text.length > inner ? `${text.slice(0, inner - 1)}\u2026` : text.padEnd(inner);
+    const shown = value.startsWith("\u26A0") ? paint(["bold", "red"], fit.slice(LABEL_WIDTH)) : fit.slice(LABEL_WIDTH);
+    return `${paint("dim", "\u2502")} ${paint("dim", fit.slice(0, LABEL_WIDTH))}${shown} ${paint("dim", "\u2502")}`;
+  });
+  return [paint("dim", `\u256D${rule}\u256E`), ...body, paint("dim", `\u2570${rule}\u256F`)];
+}
+async function statusBox(c, owner) {
+  const out = process.stdout;
+  if (!out.isTTY) return { refresh: () => {
+  }, won: () => {
+  } };
+  const token = await c.read.readContract({ address: c.net.minter, abi: minterAbi, functionName: "token" });
+  let found = 0;
+  const read2 = async () => [...await statusRows(c, token, owner, found), rpcRow(c, RPC_FIX)];
+  let rows = await read2();
+  const height = rows.length + 2;
+  const draw2 = () => {
+    const top = out.rows - height;
+    const box = render(rows, out.columns).map((l, i) => `${CSI}${top + 1 + i};1H${CSI}2K${l}`);
+    out.write(`${SAVE}${box.join("")}${RESTORE}`);
+  };
+  const reserve = () => {
+    out.write(
+      `${SAVE}${CSI}r${RESTORE}${CSI}J${"\n".repeat(height)}${CSI}${height}A${SAVE}${CSI}1;${out.rows - height}r${RESTORE}`
+    );
+    draw2();
+  };
+  const release = () => out.write(`${SAVE}${CSI}r${RESTORE}${CSI}J`);
+  reserve();
+  out.on("resize", reserve);
+  process.on("exit", release);
+  for (const signal of ["SIGINT", "SIGTERM"]) process.once(signal, () => process.exit(128 + constants.signals[signal]));
+  const refresh = coalesce(async () => {
+    try {
+      rows = await read2();
+      draw2();
+    } catch {
+    }
+  });
+  setInterval(refresh, REFRESH_MS).unref();
+  return {
+    refresh,
+    won: () => {
+      found++;
+      refresh();
+    }
+  };
+}
+
+// src/mine.ts
+async function mine(version, opts) {
+  line("hypow", `${version} \xB7 ${MAINNET.name} \xB7 minter ${short(MAINNET.minter)}`);
+  const { key, created } = loadKey();
+  line(
+    "miner key",
+    `${short(privateKeyToAccount2(key).address)} (${created ? "new, " : ""}saved to ${home().replace(process.env.HOME ?? "", "~")}) \xB7 a small separate wallet that pays mining fees`
+  );
+  const c = connect(MAINNET, key, await chooseRpc(MAINNET, opts.rpc));
+  line(...rpcRow(c, RPC_FIX));
+  const { owner, status: status2 } = await authorize(c, opts);
+  saveOwner(owner);
+  line("owner", `${short(owner)} \xB7 key authorized \xB7 miner key holds ${hype(status2.balance)} HYPE for fees`);
+  const say = explainRateLimits(line, c.own, RPC_FIX);
+  const box = await retrying(say, () => statusBox(c, owner), 5e3);
+  await run(c, owner, { line: say, search: searchInWorker, ...box, gas: box.refresh }, new AbortController().signal);
+}
+var SEARCH_WORKER = new URL(`./search-worker${extname(import.meta.url)}`, import.meta.url);
+function searchInWorker(seed, owner, k, target) {
+  const worker = new Worker(SEARCH_WORKER, { workerData: { seed, owner, k, target } });
+  return new Promise((resolve, reject) => {
+    worker.once("message", resolve);
+    worker.once("error", reject);
+  });
+}
+
+// src/cli.ts
+var USAGE = `usage: hypow mine [--owner 0x\u2026] [--gas <HYPE>] [--rpc <url>] [--no-browser]
+
+Mines on HyperEVM mainnet. The key, owner and RPC are kept in ~/.hypow/mainnet.
+
+  --owner 0x\u2026     the wallet you trade with, if you'd rather authorize by hand
+                  than through the browser page
+  --gas <HYPE>    HYPE the page sends the miner key for gas (default ${hype(MAINNET.gasFund)})
+  --rpc <url>     your own HyperEVM RPC, tried before the public ones. The
+                  first run asks for it; either way it is saved
+  --no-browser    print the authorize page's address instead of opening it
+  -h, --help      show this help
+
+On a terminal, a status box stays pinned below the log: your HYPOW, the
+attempts you have saved, blocks found this session, the miner key's gas and
+the network. Set NO_COLOR to turn off color. Piped output is plain lines.`;
+async function main() {
+  const { positionals, values } = parseArgs({
+    allowPositionals: true,
+    allowNegative: true,
+    options: {
+      owner: { type: "string" },
+      gas: { type: "string" },
+      rpc: { type: "string" },
+      browser: { type: "boolean", default: true },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  if (values.help) {
+    console.log(USAGE);
+    process.exit(0);
+  }
+  if (positionals.length !== 1 || positionals[0] !== "mine") {
+    console.log(USAGE);
+    process.exit(positionals.length === 0 ? 0 : 1);
+  }
+  if (values.owner !== void 0 && !isAddress3(values.owner)) throw new Error(`--owner ${values.owner} is not an address`);
+  const gas = values.gas === void 0 ? MAINNET.gasFund : parseEther2(values.gas);
+  if (gas < MAINNET.minGas) throw new Error(`--gas must be at least ${hype(MAINNET.minGas)} HYPE`);
+  const { version } = JSON.parse(readFileSync3(new URL("../package.json", import.meta.url), "utf8"));
+  await mine(version, {
+    owner: values.owner ? getAddress3(values.owner) : loadOwner(),
+    manual: values.owner !== void 0,
+    gas,
+    browser: values.browser,
+    rpc: values.rpc
+  });
+}
+main().catch((err) => {
+  console.error(format("error", describe(err)));
+  process.exit(1);
+});