@monolythium/core-sdk 0.1.0

package/dist/index.js

@@ -0,0 +1,2214 @@
+import { JsonRpcApiProvider, Network, AbstractSigner } from 'ethers';
+
+// src/error.ts
+var SdkError = class _SdkError extends Error {
+  kind;
+  code;
+  data;
+  constructor(kind, message, opts) {
+    super(message, opts?.cause ? { cause: opts.cause } : void 0);
+    this.name = "SdkError";
+    this.kind = kind;
+    this.code = opts?.code;
+    this.data = opts?.data;
+  }
+  static transport(message, cause) {
+    return new _SdkError("transport", message, { cause });
+  }
+  static rpc(code, message, data) {
+    return new _SdkError("rpc", `rpc error ${code}: ${message}`, { code, data });
+  }
+  static malformed(message) {
+    return new _SdkError("malformed", message);
+  }
+  static endpoint(message) {
+    return new _SdkError("endpoint", message);
+  }
+};
+
+// src/types.ts
+function encodeBlockSelector(b) {
+  if (typeof b === "number") return `0x${b.toString(16)}`;
+  if (typeof b === "bigint") return `0x${b.toString(16)}`;
+  return b;
+}
+
+// src/api.ts
+var SDK_VERSION = "0.1.0";
+function apiEndpointFromRpcEndpoint(endpoint) {
+  const raw = endpoint.trim();
+  if (raw.length === 0) {
+    throw SdkError.endpoint("endpoint cannot be empty");
+  }
+  const noTrailing = raw.replace(/\/+$/, "");
+  if (noTrailing.endsWith("/api/v1")) {
+    return noTrailing;
+  }
+  if (/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(noTrailing)) {
+    const url = new URL(noTrailing);
+    const path = url.pathname.replace(/\/+$/, "");
+    if (path === "" || path === "/" || path === "/rpc") {
+      url.pathname = "/api/v1";
+    } else if (path.endsWith("/rpc")) {
+      url.pathname = `${path.slice(0, -"/rpc".length)}/api/v1`;
+    } else {
+      url.pathname = "/api/v1";
+    }
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(/\/+$/, "");
+  }
+  return "/api/v1";
+}
+var ApiClient = class {
+  baseUrl;
+  #fetch;
+  #headers;
+  constructor(endpoint, options = {}) {
+    this.baseUrl = (options.apiBaseUrl ?? apiEndpointFromRpcEndpoint(endpoint)).replace(/\/+$/, "");
+    this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.#headers = {
+      accept: "application/json",
+      "user-agent": `monolythium-core-sdk/${SDK_VERSION}`,
+      ...options.headers ?? {}
+    };
+  }
+  async get(path, query = {}) {
+    return this.#get(path, query, false);
+  }
+  async health() {
+    return this.#get("/health", {}, true);
+  }
+  async capabilities() {
+    return this.get("/capabilities");
+  }
+  async provenance() {
+    return this.get("/provenance");
+  }
+  async search(query, limit = 10) {
+    return this.get("/search", { q: query, limit });
+  }
+  async stats() {
+    return this.get("/stats");
+  }
+  async block(block = "latest") {
+    return this.get(`/blocks/${encodePathBlock(block)}`);
+  }
+  async blockTransactions(block = "latest", page = 0, limit = 25) {
+    return this.get(`/blocks/${encodePathBlock(block)}/transactions`, { page, limit });
+  }
+  async transactions(limit = 50, cursor) {
+    return this.get("/transactions", { limit, cursor });
+  }
+  async transaction(hash) {
+    return this.get(`/transactions/${encodePathSegment(hash)}`);
+  }
+  async transactionReceipt(hash) {
+    return this.get(`/transactions/${encodePathSegment(hash)}/receipt`);
+  }
+  async addressProfile(address) {
+    return this.get(`/addresses/${encodePathSegment(address)}/profile`);
+  }
+  async addressFlow(address, limit = 250) {
+    return this.get(`/addresses/${encodePathSegment(address)}/flow`, { limit });
+  }
+  async addressActivity(address, limit = 50, cursor) {
+    return this.get(`/addresses/${encodePathSegment(address)}/activity`, {
+      limit,
+      cursor
+    });
+  }
+  async addressActivityKind(address) {
+    return this.get(`/addresses/${encodePathSegment(address)}/activity-kind`);
+  }
+  async clusters(page = 0, limit = 25) {
+    return this.get("/clusters", { page, limit });
+  }
+  async cluster(clusterId) {
+    return this.get(`/clusters/${encodePathSegment(clusterId)}`);
+  }
+  async operator(operatorId) {
+    return this.get(`/operators/${encodePathSegment(operatorId)}`);
+  }
+  async serviceProbe(peerId, serviceMask) {
+    return this.get(
+      `/service-probes/${encodePathSegment(peerId)}/${encodePathSegment(serviceMask)}`
+    );
+  }
+  async markets(limit = 50) {
+    return this.get("/markets", { limit });
+  }
+  async market(marketId) {
+    return this.get(`/markets/${encodePathSegment(marketId)}`);
+  }
+  async marketTrades(marketId, limit = 50, cursor) {
+    return this.get(`/markets/${encodePathSegment(marketId)}/trades`, { limit, cursor });
+  }
+  async marketOhlc(marketId, fromBlock, toBlock, bucketBlocks) {
+    return this.get(`/markets/${encodePathSegment(marketId)}/ohlc`, {
+      fromBlock,
+      toBlock,
+      bucketBlocks
+    });
+  }
+  async marketOrderBook(marketId, levels = 20) {
+    return this.get(`/markets/${encodePathSegment(marketId)}/orderbook`, { levels });
+  }
+  async upgradeStatus(height) {
+    return this.get("/upgrades/status", {
+      height: height == null ? void 0 : encodeBlockSelector(height)
+    });
+  }
+  async #get(path, query, allowUnavailableBody) {
+    const url = buildUrl(this.baseUrl, path, query);
+    let resp;
+    try {
+      resp = await this.#fetch(url, {
+        method: "GET",
+        headers: this.#headers
+      });
+    } catch (cause) {
+      throw SdkError.transport(
+        `transport failure calling ${url}: ${cause?.message ?? cause}`,
+        cause
+      );
+    }
+    let parsed;
+    try {
+      parsed = await resp.json();
+    } catch (cause) {
+      throw SdkError.malformed(
+        `non-JSON response (HTTP ${resp.status}): ${cause?.message ?? cause}`
+      );
+    }
+    const error = parseApiError(parsed);
+    if (error) {
+      throw SdkError.rpc(error.code, error.message, error.data);
+    }
+    if (!resp.ok && !(allowUnavailableBody && resp.status === 503)) {
+      throw SdkError.transport(`HTTP ${resp.status} calling ${url}`);
+    }
+    return parsed;
+  }
+};
+function parseApiError(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  const error = value["error"];
+  if (!error || typeof error !== "object" || Array.isArray(error)) return null;
+  const row = error;
+  if (typeof row["code"] !== "number" || typeof row["message"] !== "string") {
+    return null;
+  }
+  return {
+    code: row["code"],
+    message: row["message"],
+    data: row["data"]
+  };
+}
+function buildUrl(baseUrl, path, query) {
+  const cleanBase = baseUrl.replace(/\/+$/, "");
+  const cleanPath = path.startsWith("/") ? path : `/${path}`;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null) continue;
+    params.set(key, typeof value === "bigint" ? value.toString() : String(value));
+  }
+  const qs = params.toString();
+  return qs.length === 0 ? `${cleanBase}${cleanPath}` : `${cleanBase}${cleanPath}?${qs}`;
+}
+function encodePathBlock(block) {
+  return encodePathSegment(encodeBlockSelector(block));
+}
+function encodePathSegment(value) {
+  return encodeURIComponent(typeof value === "bigint" ? value.toString() : String(value));
+}
+
+// src/consts.ts
+var BURN_ADDR = "0x0000000000000000000000000000000000000000";
+var PRECOMPILE_ADDRESSES = {
+  /** Native fungible-token factory — non-gateable, foundational. */
+  TOKEN_FACTORY: "0x0000000000000000000000000000000000001000",
+  /** Native central-limit order book — gateable. */
+  CLOB: "0x0000000000000000000000000000000000001001",
+  /** Agent execution surface (zkML-gated, ADR-0011/ADR-0020) — gateable. */
+  AGENT: "0x0000000000000000000000000000000000001003",
+  /** Account privacy policy + stealth/confidential ops — gateable. */
+  PRIVACY: "0x0000000000000000000000000000000000001004",
+  /** Operator + RPC node registry — non-gateable consensus invariant. */
+  NODE_REGISTRY: "0x0000000000000000000000000000000000001005",
+  /** IBC light-client + packet routing — gateable. */
+  IBC: "0x0000000000000000000000000000000000001007",
+  /** Native zk-light-client bridge — gateable. */
+  BRIDGE: "0x0000000000000000000000000000000000001008",
+  /** Decentralized multi-signer oracle (OI-0036) — non-gateable. */
+  ORACLE: "0x0000000000000000000000000000000000001009",
+  /** Distributed delegation primitive (Stage E.5a, Law §7.6) — gateable. */
+  DELEGATION: "0x000000000000000000000000000000000000100A",
+  /** One-time emergency-key registry (Law §5.4 / §2.9) — non-gateable. */
+  EMERGENCY_KEY: "0x0000000000000000000000000000000000001100",
+  /** VRF precompile (Law §5.4 / §5.6). */
+  VRF: "0x0000000000000000000000000000000000001101",
+  /** Streaming-payments primitive (Law §5.4 / §5.7) — gateable. */
+  STREAMING_PAYMENTS: "0x0000000000000000000000000000000000001102",
+  /** Human-readable name registry (Law §5.4 / §5.8) — gateable. */
+  NAME_REGISTRY: "0x0000000000000000000000000000000000001103",
+  /** Cluster-name registry. */
+  CLUSTER_NAME_REGISTRY: "0x0000000000000000000000000000000000001104",
+  /** Agent-commerce attestation precompile. */
+  ATTESTATION: "0x0000000000000000000000000000000000001105",
+  /** Agent-commerce consent precompile. */
+  CONSENT: "0x0000000000000000000000000000000000001106",
+  /** Agent-commerce issuer registry. */
+  ISSUER_REGISTRY: "0x0000000000000000000000000000000000001107",
+  /** Agent-commerce discovery precompile. */
+  DISCOVERY: "0x0000000000000000000000000000000000001108",
+  /** Agent-commerce availability precompile. */
+  AVAILABILITY: "0x0000000000000000000000000000000000001109",
+  /** Agent-commerce escrow precompile. */
+  ESCROW: "0x000000000000000000000000000000000000110A",
+  /** Agent-commerce arbiter registry. */
+  ARBITER_REGISTRY: "0x000000000000000000000000000000000000110B",
+  /** Agent spending policy — gateable, activated by Stage 7 milestones. */
+  SPENDING_POLICY: "0x000000000000000000000000000000000000110C",
+  /** Primary ML-DSA-65 pubkey registry — gateable, ADR-0034. */
+  PUBKEY_REGISTRY: "0x000000000000000000000000000000000000110D"
+};
+
+// src/node-registry.ts
+var NODE_REGISTRY_CAPABILITIES = {
+  SERVES_RPC: 1,
+  SERVES_INDEXER: 2,
+  SERVES_BROADCASTER: 4,
+  SERVES_ARCHIVE: 8,
+  SERVES_WEBSOCKET: 16,
+  SERVES_LIGHT_CLIENT: 32,
+  SERVES_ORACLE_WRITER: 64,
+  SERVES_BRIDGE_RELAY: 128,
+  SERVES_PUBLIC_API: 256
+};
+var NODE_REGISTRY_CAPABILITY_MASK = 65535;
+var NODE_REGISTRY_PUBLIC_SERVICE_MASK = NODE_REGISTRY_CAPABILITIES.SERVES_RPC | NODE_REGISTRY_CAPABILITIES.SERVES_INDEXER | NODE_REGISTRY_CAPABILITIES.SERVES_ARCHIVE | NODE_REGISTRY_CAPABILITIES.SERVES_WEBSOCKET | NODE_REGISTRY_CAPABILITIES.SERVES_PUBLIC_API;
+var SERVICE_PROBE_STATUS = {
+  UNKNOWN: 0,
+  REACHABLE: 1,
+  DEGRADED: 2,
+  UNREACHABLE: 3
+};
+var NODE_REGISTRY_SELECTORS = {
+  reportServiceProbe: "0xeee31bba",
+  getServiceProbe: "0x1fcbfbce"
+};
+var NodeRegistryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NodeRegistryError";
+  }
+};
+function nodeRegistryAddressHex() {
+  return PRECOMPILE_ADDRESSES.NODE_REGISTRY.toLowerCase();
+}
+function isValidNodeRegistryCapabilities(flags) {
+  return Number.isInteger(flags) && flags >= 0 && (flags & ~NODE_REGISTRY_CAPABILITY_MASK) === 0;
+}
+function isValidPublicServiceProbeMask(mask) {
+  return Number.isInteger(mask) && mask > 0 && (mask & ~NODE_REGISTRY_PUBLIC_SERVICE_MASK) === 0;
+}
+function isSinglePublicServiceProbeMask(mask) {
+  return isValidPublicServiceProbeMask(mask) && bitCount(mask) === 1;
+}
+function isConcreteServiceProbeStatus(status) {
+  return status === SERVICE_PROBE_STATUS.REACHABLE || status === SERVICE_PROBE_STATUS.DEGRADED || status === SERVICE_PROBE_STATUS.UNREACHABLE;
+}
+function serviceProbeStatusLabel(status) {
+  switch (status) {
+    case SERVICE_PROBE_STATUS.REACHABLE:
+      return "reachable";
+    case SERVICE_PROBE_STATUS.DEGRADED:
+      return "degraded";
+    case SERVICE_PROBE_STATUS.UNREACHABLE:
+      return "unreachable";
+    default:
+      return "unknown";
+  }
+}
+function encodeReportServiceProbeCalldata(args) {
+  if (!isValidPublicServiceProbeMask(args.serviceMask)) {
+    throw new NodeRegistryError(
+      `serviceMask 0x${args.serviceMask.toString(16).padStart(8, "0")} is not a valid public-service mask`
+    );
+  }
+  if (!isConcreteServiceProbeStatus(args.status)) {
+    throw new NodeRegistryError(`status ${args.status} is not a concrete service-probe outcome`);
+  }
+  const latencyMs = expectUint32(args.latencyMs, "latencyMs");
+  return bytesToHex(
+    concatBytes(
+      hexToBytes(NODE_REGISTRY_SELECTORS.reportServiceProbe),
+      expectLength(toBytes(args.peerId), 32, "peerId"),
+      uint32Word(args.serviceMask),
+      uint8Word(args.status),
+      uint32Word(latencyMs),
+      expectLength(toBytes(args.probeDigest), 32, "probeDigest")
+    )
+  );
+}
+function bitCount(value) {
+  let n = value >>> 0;
+  let count = 0;
+  while (n !== 0) {
+    count += n & 1;
+    n >>>= 1;
+  }
+  return count;
+}
+function expectUint32(value, name) {
+  if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+    throw new NodeRegistryError(`${name} must be a uint32`);
+  }
+  return value;
+}
+function uint32Word(value) {
+  const out = new Uint8Array(32);
+  const n = expectUint32(value, "uint32");
+  out[28] = n >>> 24 & 255;
+  out[29] = n >>> 16 & 255;
+  out[30] = n >>> 8 & 255;
+  out[31] = n & 255;
+  return out;
+}
+function uint8Word(value) {
+  if (!Number.isInteger(value) || value < 0 || value > 255) {
+    throw new NodeRegistryError("uint8 value out of range");
+  }
+  const out = new Uint8Array(32);
+  out[31] = value;
+  return out;
+}
+function toBytes(value) {
+  if (typeof value === "string") {
+    return hexToBytes(value);
+  }
+  return value instanceof Uint8Array ? value : Uint8Array.from(value);
+}
+function hexToBytes(hex) {
+  const body = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+  if (body.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(body)) {
+    throw new NodeRegistryError("invalid hex bytes");
+  }
+  const out = new Uint8Array(body.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Number.parseInt(body.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function bytesToHex(bytes) {
+  return `0x${[...bytes].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+function concatBytes(...parts) {
+  const out = new Uint8Array(parts.reduce((acc, p) => acc + p.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function expectLength(value, len, name) {
+  if (value.length !== len) {
+    throw new NodeRegistryError(`${name} must be ${len} bytes, got ${value.length}`);
+  }
+  return value;
+}
+
+// src/registry.ts
+var TESTNET_69420 = {
+  chain_id: 69420,
+  network: "testnet-69420",
+  display_name: "Monolythium Testnet",
+  description: "Live development testnet for Monolythium v4.0 / LythiumDAG-BFT. Foundation-operated. Wipe + regenesis is allowed without notice \u2014 do NOT store value on this network.",
+  genesis_hash: "0x325057e476b7be3730a22c92b9289f4a14a3414a2a081bd279b43eeba36b0075",
+  binary_sha: "44a9ec4",
+  rpc: [
+    {
+      url: "http://178.105.15.216:8545",
+      provider: "monolythium-foundation",
+      region: "fsn1",
+      tier: "official",
+      notes: "operator-2; primary foundation seed (operator-1 offline pending BLS key reissue)"
+    },
+    {
+      url: "http://178.104.233.182:8545",
+      provider: "monolythium-foundation",
+      region: "nbg1",
+      tier: "official",
+      notes: "operator-3"
+    },
+    {
+      url: "http://65.108.94.1:8545",
+      provider: "monolythium-foundation",
+      region: "hel1",
+      tier: "official",
+      notes: "operator-4"
+    },
+    {
+      url: "http://95.216.154.155:8545",
+      provider: "monolythium-foundation",
+      region: "hel1",
+      tier: "official",
+      notes: "operator-5"
+    },
+    {
+      url: "http://87.99.145.48:8545",
+      provider: "monolythium-foundation",
+      region: "ash",
+      tier: "official",
+      notes: "operator-6; US east"
+    },
+    {
+      url: "http://5.223.85.76:8545",
+      provider: "monolythium-foundation",
+      region: "sin",
+      tier: "official",
+      notes: "operator-7; APAC"
+    }
+  ],
+  p2p: [
+    {
+      multiaddr: "/ip4/178.105.15.216/tcp/29898/p2p/12D3KooWDKk9ALxqchazXGcRGbqyopWtAGRbf4WQFS2dABV7gQGb",
+      region: "fsn1"
+    },
+    {
+      multiaddr: "/ip4/178.104.233.182/tcp/29898/p2p/12D3KooW9uVG8csFCtSxoFaYBsGzXBgVwQhAw84TGj4dfRi9LH1c",
+      region: "nbg1"
+    },
+    {
+      multiaddr: "/ip4/65.108.94.1/tcp/29898/p2p/12D3KooWKvkjEVkA64TdbSoVjDW2sWUzgkAMbPZsZvfxZw2W6zVy",
+      region: "hel1"
+    },
+    {
+      multiaddr: "/ip4/95.216.154.155/tcp/29898/p2p/12D3KooWCcVjSuERAGzG6Xb3wjUj22fGrgP2QXDJfquxQ72TBMd8",
+      region: "hel1"
+    },
+    {
+      multiaddr: "/ip4/87.99.145.48/tcp/29898/p2p/12D3KooWMKw9Qxx7RE3PjQGMZq94C23UDjnTbZCNWFy6Dc4YcCdL",
+      region: "ash"
+    },
+    {
+      multiaddr: "/ip4/5.223.85.76/tcp/29898/p2p/12D3KooWSTeApBSKR4DpKvJAuqKfHxNhdbNg9mi9u8f4UNfzN5Cu",
+      region: "sin"
+    }
+  ]
+};
+var CHAIN_REGISTRY = {
+  "testnet-69420": TESTNET_69420
+};
+var CHAIN_REGISTRY_RAW_BASE = "https://raw.githubusercontent.com/monolythium/chain-registry/master/chains";
+function getChainInfo(network) {
+  const info = CHAIN_REGISTRY[network];
+  if (!info) {
+    throw new Error(`unknown Monolythium network: ${network}`);
+  }
+  return info;
+}
+function getRpcEndpoints(network) {
+  return getChainInfo(network).rpc;
+}
+function getP2pSeeds(network) {
+  return getChainInfo(network).p2p;
+}
+async function fetchChainInfoLatest(network, options = {}) {
+  const fetchImpl = options.fetch ?? globalThis.fetch.bind(globalThis);
+  const rawBaseUrl = options.rawBaseUrl ?? CHAIN_REGISTRY_RAW_BASE;
+  const resp = await fetchImpl(`${rawBaseUrl}/${network}.toml`);
+  if (!resp.ok) {
+    throw new Error(`failed to fetch chain registry ${network}: HTTP ${resp.status}`);
+  }
+  return parseChainRegistryToml(await resp.text());
+}
+async function fetchChainRegistryLatest(networks = ["testnet-69420"], options = {}) {
+  const entries = await Promise.all(
+    networks.map(async (network) => [network, await fetchChainInfoLatest(network, options)])
+  );
+  return Object.fromEntries(entries);
+}
+function parseChainRegistryToml(input) {
+  const info = {
+    rpc: [],
+    p2p: [],
+    explorer: []
+  };
+  let section = "root";
+  for (const rawLine of input.split(/\r?\n/)) {
+    const line = rawLine.replace(/\s+#.*$/, "").trim();
+    if (!line || line.startsWith("#")) continue;
+    if (line === "[[rpc]]") {
+      section = "rpc";
+      info.rpc.push({ url: "", provider: "", tier: "community" });
+      continue;
+    }
+    if (line === "[[p2p]]") {
+      section = "p2p";
+      info.p2p.push({ multiaddr: "" });
+      continue;
+    }
+    if (line === "[[explorer]]") {
+      section = "explorer";
+      info.explorer.push({ url: "", name: "" });
+      continue;
+    }
+    const match = /^([A-Za-z0-9_]+)\s*=\s*(.+)$/.exec(line);
+    if (!match) continue;
+    const [, key, rawValue] = match;
+    const value = parseTomlScalar(rawValue);
+    if (section === "root") {
+      info[key] = value;
+    } else {
+      const list = info[section];
+      const target = list[list.length - 1];
+      target[key] = value;
+    }
+  }
+  if (!info.network || !info.chain_id || !info.genesis_hash || !info.binary_sha) {
+    throw new Error("chain registry TOML is missing required top-level fields");
+  }
+  if (info.rpc.length === 0 || info.rpc.some((r) => !r.url || !r.provider || !r.tier)) {
+    throw new Error("chain registry TOML must include at least one complete rpc endpoint");
+  }
+  if (info.p2p.length === 0 || info.p2p.some((p) => !p.multiaddr)) {
+    throw new Error("chain registry TOML must include at least one p2p seed");
+  }
+  const out = {
+    chain_id: Number(info.chain_id),
+    network: String(info.network),
+    display_name: info.display_name ? String(info.display_name) : void 0,
+    description: info.description ? String(info.description) : void 0,
+    genesis_hash: String(info.genesis_hash),
+    binary_sha: String(info.binary_sha),
+    rpc: info.rpc,
+    p2p: info.p2p
+  };
+  if (info.explorer.length > 0) out.explorer = info.explorer;
+  return out;
+}
+function parseTomlScalar(raw) {
+  const value = raw.trim();
+  if (value.startsWith('"') && value.endsWith('"')) {
+    return value.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (/^-?\d+$/.test(value)) return Number(value);
+  return value;
+}
+
+// src/client.ts
+var SDK_VERSION2 = "0.1.0";
+function resolveChainInfo(network, registry) {
+  if (registry) {
+    const info = registry[network];
+    if (!info) {
+      throw SdkError.endpoint(`unknown Monolythium network: ${network}`);
+    }
+    return info;
+  }
+  try {
+    return getChainInfo(network);
+  } catch (err) {
+    throw SdkError.endpoint(err?.message ?? String(err));
+  }
+}
+var RpcClient = class _RpcClient {
+  endpoint;
+  #fetch;
+  #headers;
+  #nextId;
+  constructor(endpoint, options = {}) {
+    if (!endpoint || endpoint.length === 0) {
+      throw SdkError.endpoint("endpoint cannot be empty");
+    }
+    this.endpoint = endpoint;
+    this.#fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.#headers = {
+      "content-type": "application/json",
+      "user-agent": `monolythium-core-sdk/${SDK_VERSION2}`,
+      ...options.headers ?? {}
+    };
+    this.#nextId = 1;
+  }
+  /**
+   * Construct a client from the chain-registry network slug.
+   *
+   * Defaults to the SDK-bundled registry snapshot from
+   * `monolythium/chain-registry`. Set `probe: true` to walk the
+   * registry endpoints in order and return the first endpoint whose
+   * `eth_chainId` matches the registry chain id.
+   */
+  static async forNetwork(network = "testnet-69420", options = {}) {
+    const info = resolveChainInfo(network, options.registry);
+    if (info.rpc.length === 0) {
+      throw SdkError.endpoint(`network ${network} has no RPC endpoints`);
+    }
+    if (options.probe) {
+      return this.fromFirstReachable(info, options);
+    }
+    return new _RpcClient(info.rpc[0].url, options);
+  }
+  /**
+   * Walk a chain-registry entry in order and return the first endpoint
+   * whose `eth_chainId` matches the registry `chain_id`.
+   */
+  static async fromFirstReachable(chain, options = {}) {
+    const errors = [];
+    for (const endpoint of chain.rpc) {
+      const client = new _RpcClient(endpoint.url, options);
+      try {
+        const chainId = await client.ethChainId();
+        if (chainId === BigInt(chain.chain_id)) {
+          return client;
+        }
+        errors.push(`${endpoint.url}: chain id ${chainId} != ${chain.chain_id}`);
+      } catch (err) {
+        errors.push(`${endpoint.url}: ${err?.message ?? err}`);
+      }
+    }
+    throw SdkError.endpoint(
+      `no reachable RPC endpoint for ${chain.network}; tried ${errors.join("; ")}`
+    );
+  }
+  /**
+   * Send an arbitrary JSON-RPC method. Most callers should prefer the
+   * typed wrappers below; this is the escape hatch for methods the
+   * SDK does not yet wrap.
+   */
+  async call(method, params = []) {
+    const id = this.#nextId++;
+    const body = { jsonrpc: "2.0", id, method, params };
+    let resp;
+    try {
+      resp = await this.#fetch(this.endpoint, {
+        method: "POST",
+        headers: this.#headers,
+        body: JSON.stringify(body)
+      });
+    } catch (cause) {
+      throw SdkError.transport(
+        `transport failure calling ${method}: ${cause?.message ?? cause}`,
+        cause
+      );
+    }
+    let parsed;
+    try {
+      parsed = await resp.json();
+    } catch (cause) {
+      throw SdkError.malformed(
+        `non-JSON response (HTTP ${resp.status}): ${cause?.message ?? cause}`
+      );
+    }
+    if (parsed.error) {
+      throw SdkError.rpc(parsed.error.code, parsed.error.message, parsed.error.data);
+    }
+    if (!("result" in parsed) || parsed.result === void 0) {
+      if (!resp.ok) {
+        throw SdkError.malformed(`HTTP ${resp.status} with no JSON-RPC result`);
+      }
+      throw SdkError.malformed("response is missing both `result` and `error`");
+    }
+    return parsed.result;
+  }
+  // ---- eth_* / net_* / web3_* ---------------------------------------
+  /** `eth_chainId` — configured chain id. */
+  async ethChainId() {
+    return parseQuantityBig(await this.call("eth_chainId", []));
+  }
+  /** `eth_blockNumber` — latest committed height. */
+  async ethBlockNumber() {
+    return parseQuantityBig(await this.call("eth_blockNumber", []));
+  }
+  /** `eth_getBalance` — balance + Merkle proof envelope. */
+  async ethGetBalance(address, block = "latest") {
+    return this.call("eth_getBalance", [address, encodeBlockSelector(block)]);
+  }
+  /** `eth_getStorageAt` — storage word + Merkle proof. */
+  async ethGetStorageAt(address, slot, block = "latest") {
+    return this.call("eth_getStorageAt", [
+      address,
+      slot,
+      encodeBlockSelector(block)
+    ]);
+  }
+  /** `eth_getTransactionCount` — sender nonce. */
+  async ethGetTransactionCount(address, block = "latest") {
+    return parseQuantityBig(
+      await this.call("eth_getTransactionCount", [
+        address,
+        encodeBlockSelector(block)
+      ])
+    );
+  }
+  /** `eth_getCode` — deployed bytecode (`0x` for an EOA, `0xfe` for a precompile). */
+  async ethGetCode(address, block = "latest") {
+    return this.call("eth_getCode", [address, encodeBlockSelector(block)]);
+  }
+  /** `eth_getBlockByNumber` — fetch a block header by height/tag. */
+  async ethGetBlockByNumber(block = "latest") {
+    return normalizeBlockHeader(await this.call("eth_getBlockByNumber", [encodeBlockSelector(block)]));
+  }
+  /** `eth_getBlockByHash` — fetch a block header by hash. */
+  async ethGetBlockByHash(hash) {
+    return normalizeBlockHeader(await this.call("eth_getBlockByHash", [hash]));
+  }
+  /** `eth_getTransactionByHash` — fetch an included transaction by hash. */
+  async ethGetTransactionByHash(txHash) {
+    return this.call("eth_getTransactionByHash", [txHash]);
+  }
+  /** `eth_getTransactionReceipt` — receipt for a confirmed tx. */
+  async ethGetTransactionReceipt(txHash) {
+    return this.call("eth_getTransactionReceipt", [txHash]);
+  }
+  /** `eth_sendRawTransaction` — submit a signed raw tx. */
+  async ethSendRawTransaction(rawTx) {
+    return this.call("eth_sendRawTransaction", [rawTx]);
+  }
+  /** `eth_call` — dry-run a transaction. */
+  async ethCall(request, block = "latest") {
+    return this.call("eth_call", [request, encodeBlockSelector(block)]);
+  }
+  /** `eth_estimateGas` — gas estimate for a dry-run. */
+  async ethEstimateGas(request, block = "latest") {
+    return parseQuantityBig(
+      await this.call("eth_estimateGas", [request, encodeBlockSelector(block)])
+    );
+  }
+  /** `eth_gasPrice` — minimum gas price the node will accept. */
+  async ethGasPrice() {
+    return parseQuantityBig(await this.call("eth_gasPrice", []));
+  }
+  /** `eth_feeHistory` — base-fee + gas-used history. */
+  async ethFeeHistory(blockCount, newestBlock = "latest", rewardPercentiles = []) {
+    return this.call("eth_feeHistory", [
+      `0x${blockCount.toString(16)}`,
+      encodeBlockSelector(newestBlock),
+      rewardPercentiles
+    ]);
+  }
+  /** `eth_syncing` — `null` when caught up. */
+  async ethSyncing() {
+    const v = await this.call("eth_syncing", []);
+    if (v === false || v === null || v === void 0) return null;
+    return v;
+  }
+  /** `net_version` — chain id as a decimal string. */
+  async netVersion() {
+    return this.call("net_version", []);
+  }
+  /** `net_peerCount` — number of connected peers. */
+  async netPeerCount() {
+    return parseQuantityBig(await this.call("net_peerCount", []));
+  }
+  /** `net_listening` — whether the node accepts inbound peers. */
+  async netListening() {
+    return this.call("net_listening", []);
+  }
+  /** `web3_clientVersion` — server's client-version string. */
+  async web3ClientVersion() {
+    return this.call("web3_clientVersion", []);
+  }
+  /** `web3_sha3` — Keccak-256 of `data`. */
+  async web3Sha3(data) {
+    return this.call("web3_sha3", [data]);
+  }
+  // ---- lyth_* (Law §13.2 native namespace) --------------------------
+  /** `lyth_listProviders` — paged registry enumeration. */
+  async lythListProviders(capabilityMask, cursor = null, limit = 100) {
+    return this.call("lyth_listProviders", [capabilityMask, cursor, limit]);
+  }
+  /** `lyth_getRegistration` — single registry lookup. */
+  async lythGetRegistration(peerId) {
+    return this.call("lyth_getRegistration", [peerId]);
+  }
+  /** `lyth_registryStateProof` — Merkle proof for a registry entry. */
+  async lythRegistryStateProof(peerId) {
+    return this.call("lyth_registryStateProof", [peerId]);
+  }
+  /** `lyth_getAccountPolicy` — privacy posture for an account. */
+  async lythGetAccountPolicy(address) {
+    return this.call("lyth_getAccountPolicy", [address]);
+  }
+  /** `lyth_getAssetPolicy` — privacy posture for an asset. */
+  async lythGetAssetPolicy(tokenId) {
+    return this.call("lyth_getAssetPolicy", [tokenId]);
+  }
+  /** `lyth_getTokenBalances` — indexed per-asset balances for one address. */
+  async lythGetTokenBalances(address) {
+    return this.call("lyth_getTokenBalances", [address]);
+  }
+  /** `lyth_getAddressLabel` — indexed display/category label for one address. */
+  async lythGetAddressLabel(address) {
+    const v = await this.call("lyth_getAddressLabel", [address]);
+    if (v === null || v === void 0) return null;
+    return v;
+  }
+  /** `lyth_getAddressActivity` — indexed per-address activity timeline. */
+  async lythGetAddressActivity(address, limit = 50, cursor) {
+    const params = cursor === void 0 ? [address, limit] : [address, limit, cursor];
+    return this.call("lyth_getAddressActivity", params);
+  }
+  /** `lyth_addressActivityKind` — activity index coverage for one address. */
+  async lythAddressActivityKind(address) {
+    return this.call("lyth_addressActivityKind", [address]);
+  }
+  /** `lyth_decodeTx` — explorer-grade decoded transaction envelope. */
+  async lythDecodeTx(txHash) {
+    return this.call("lyth_decodeTx", [txHash]);
+  }
+  /** `lyth_gapRecords` — retained ingestion/indexing gaps for a block range. */
+  async lythGapRecords(fromBlock, toBlock) {
+    return this.call("lyth_gapRecords", [
+      encodeRpcU64Number(fromBlock, "fromBlock"),
+      encodeRpcU64Number(toBlock, "toBlock")
+    ]);
+  }
+  /** `lyth_dagParents` — parent vertices for a DAG round. */
+  async lythDagParents(round) {
+    return this.call("lyth_dagParents", [encodeRpcU64Number(round, "round")]);
+  }
+  /** `lyth_richList` — top holders for a token id. */
+  async lythRichList(tokenId, limit) {
+    const params = limit == null ? [tokenId] : [tokenId, limit];
+    return this.call("lyth_richList", params);
+  }
+  /** `lyth_clobMarket` — live CLOB market metadata for a market id. */
+  async lythClobMarket(marketId) {
+    return this.call("lyth_clobMarket", [marketId]);
+  }
+  /** `lyth_clobMarkets` — CLOB markets observed through indexed trades. */
+  async lythClobMarkets(limit) {
+    const params = limit == null ? [] : [limit];
+    return this.call("lyth_clobMarkets", params);
+  }
+  /** `lyth_clobTrades` — CLOB fills for one market. */
+  async lythClobTrades(marketId, limit = 50, cursor) {
+    const params = cursor === void 0 ? [marketId, limit] : [marketId, limit, cursor];
+    return this.call("lyth_clobTrades", params);
+  }
+  /** `lyth_clobOhlc` — CLOB OHLC candles for a market over a block range. */
+  async lythClobOhlc(marketId, fromBlock, toBlock, bucketBlocks) {
+    const params = fromBlock == null && toBlock == null && bucketBlocks == null ? [marketId] : [
+      marketId,
+      fromBlock == null ? null : encodeRpcU64Number(fromBlock, "fromBlock"),
+      toBlock == null ? null : encodeRpcU64Number(toBlock, "toBlock"),
+      bucketBlocks == null ? null : encodeRpcU64Number(bucketBlocks, "bucketBlocks")
+    ];
+    return this.call("lyth_clobOhlc", params);
+  }
+  /** `lyth_clobOrderBook` — live CLOB depth from canonical state. */
+  async lythClobOrderBook(marketId, levels) {
+    const params = levels == null ? [marketId] : [marketId, levels];
+    return this.call("lyth_clobOrderBook", params);
+  }
+  /** `lyth_txFeed` — paged global transaction feed. */
+  async lythTxFeed(limit = 50, cursor) {
+    const params = cursor === void 0 ? [limit] : [limit, cursor];
+    return this.call("lyth_txFeed", params);
+  }
+  /** `lyth_addressProfile` — live account + label + activity aggregate. */
+  async lythAddressProfile(address) {
+    return this.call("lyth_addressProfile", [address]);
+  }
+  /** `lyth_addressFlow` — recent indexed address-flow aggregate. */
+  async lythAddressFlow(address, limit = 250) {
+    return this.call("lyth_addressFlow", [address, limit]);
+  }
+  /** `lyth_search` — exact live resolver for hashes, addresses, blocks, and clusters. */
+  async lythSearch(query, limit = 10) {
+    return this.call("lyth_search", [query, limit]);
+  }
+  /** `lyth_chainStats` — compact live chain/indexer/mempool summary. */
+  async lythChainStats() {
+    return this.call("lyth_chainStats", []);
+  }
+  /** `lyth_mempoolStatus` — aggregate mempool snapshot. */
+  async lythMempoolStatus() {
+    return normalizeMempoolSnapshot(await this.call("lyth_mempoolStatus", []));
+  }
+  /** `lyth_mempoolPending` — pending txs for a sender. */
+  async lythMempoolPending(sender) {
+    return this.call("lyth_mempoolPending", [sender]);
+  }
+  /** `lyth_currentRound` — latest committed height. */
+  async lythCurrentRound() {
+    return normalizeRoundInfo(await this.call("lyth_currentRound", []));
+  }
+  /** `lyth_peerSummary` — public-safe aggregate peer-network diagnostics. */
+  async lythPeerSummary() {
+    return this.call("lyth_peerSummary", []);
+  }
+  /**
+   * `lyth_listActivePrecompiles` — milestone-gated precompile catalogue
+   * (OI-0170 / ADR-0015 §5).
+   */
+  async lythListActivePrecompiles(block = "latest") {
+    return this.call("lyth_listActivePrecompiles", [encodeBlockSelector(block)]);
+  }
+  /** `lyth_capabilities` — address-keyed precompile capability map. */
+  async lythCapabilities(block) {
+    const params = block === void 0 ? [] : [encodeBlockSelector(block)];
+    return this.call("lyth_capabilities", params);
+  }
+  /**
+   * `lyth_operatorCapabilities` — node-level availability for operator UI
+   * and explorer surfaces.
+   */
+  async lythOperatorCapabilities() {
+    return this.call("lyth_operatorCapabilities", []);
+  }
+  /** `lyth_indexerStatus` — indexer status; `null` when disabled. */
+  async lythIndexerStatus() {
+    const v = await this.call("lyth_indexerStatus", []);
+    if (v === null || v === void 0) return null;
+    return v;
+  }
+  /** `lyth_getStorageProof` — batched Merkle proofs. */
+  async lythGetStorageProof(address, slots) {
+    return this.call("lyth_getStorageProof", [address, slots]);
+  }
+  /** `lyth_getDelegations` — wallet delegation rows at a block. */
+  async lythGetDelegations(wallet, block) {
+    const params = block === void 0 ? [wallet] : [wallet, encodeBlockSelector(block)];
+    return this.call("lyth_getDelegations", params);
+  }
+  /** `lyth_getDelegationHistory` — indexed per-wallet delegation event timeline. */
+  async lythGetDelegationHistory(wallet, limit = 50, cursor) {
+    const params = cursor === void 0 ? [wallet, limit] : [wallet, limit, cursor];
+    return this.call("lyth_getDelegationHistory", params);
+  }
+  /** `lyth_getClusterDelegators` — delegator addresses for a cluster. */
+  async lythGetClusterDelegators(cluster, block) {
+    const params = block === void 0 ? [cluster] : [cluster, encodeBlockSelector(block)];
+    return this.call("lyth_getClusterDelegators", params);
+  }
+  /** `lyth_getDelegationCap` — active per-cluster cap at a block. */
+  async lythGetDelegationCap(block) {
+    const params = block === void 0 ? [] : [encodeBlockSelector(block)];
+    return this.call("lyth_getDelegationCap", params);
+  }
+  /** `lyth_getTpmAttestation` — TPM quote digest + EK id for a peer. */
+  async lythGetTpmAttestation(peerId, block) {
+    const params = block === void 0 ? [peerId] : [peerId, encodeBlockSelector(block)];
+    return this.call("lyth_getTpmAttestation", params);
+  }
+  /** `lyth_getClusterEntity` — entity flag for a cluster. */
+  async lythGetClusterEntity(cluster, block) {
+    const params = block === void 0 ? [cluster] : [cluster, encodeBlockSelector(block)];
+    return this.call("lyth_getClusterEntity", params);
+  }
+  /** `lyth_getEntityRatchet` — entity-ratchet snapshot at a block. */
+  async lythGetEntityRatchet(block) {
+    const params = block === void 0 ? [] : [encodeBlockSelector(block)];
+    return this.call("lyth_getEntityRatchet", params);
+  }
+  /** `lyth_operatorInfo` — canonical operator identity envelope. */
+  async lythOperatorInfo(operatorId) {
+    return normalizeOperatorInfo(await this.call("lyth_operatorInfo", [operatorId]));
+  }
+  /** `lyth_getServiceProbe` — latest external reachability report for one public service. */
+  async lythGetServiceProbe(peerId, serviceMask) {
+    assertHexBytes(peerId, 32, "peerId");
+    if (!isSinglePublicServiceProbeMask(serviceMask)) {
+      throw SdkError.malformed("serviceMask must contain exactly one public-service bit");
+    }
+    const value = await this.call("lyth_getServiceProbe", [peerId, serviceMask]);
+    if (value === null || value === void 0) return null;
+    return normalizeServiceProbe(value);
+  }
+  /** `lyth_reportServiceProbe` — submit a pre-signed public-service probe report. */
+  async lythReportServiceProbe(req) {
+    assertHexBytes(req.peerId, 32, "peerId");
+    if (!isValidPublicServiceProbeMask(req.serviceMask)) {
+      throw SdkError.malformed("serviceMask must name one or more public-service bits");
+    }
+    if (!isConcreteServiceProbeStatus(req.status)) {
+      throw SdkError.malformed("status must be reachable, degraded, or unreachable");
+    }
+    assertSafeUint32(req.latencyMs, "latencyMs");
+    assertHexBytes(req.probeDigest, 32, "probeDigest");
+    assertNonEmptyHex(req.signedRawTx, "signedRawTx");
+    return this.call("lyth_reportServiceProbe", [req]);
+  }
+  /** `lyth_clusterStatus` — canonical cluster status envelope. */
+  async lythClusterStatus(clusterId) {
+    return normalizeClusterStatus(await this.call("lyth_clusterStatus", [clusterId]));
+  }
+  /** `lyth_clusterDirectory` — paged public cluster directory. */
+  async lythClusterDirectory(page = 0, limit = 25) {
+    return normalizeClusterDirectoryPage(
+      await this.call("lyth_clusterDirectory", [page, limit])
+    );
+  }
+  /** `lyth_clusters` — alias for `lyth_clusterDirectory`. */
+  async lythClusters(page = 0, limit = 25) {
+    return normalizeClusterDirectoryPage(await this.call("lyth_clusters", [page, limit]));
+  }
+  /**
+   * `lyth_submitPendingChange` — operator-onboarding transport for the
+   * pending-change ledger. Server validates the envelope shape.
+   */
+  async lythSubmitPendingChange(envelope) {
+    return this.call("lyth_submitPendingChange", [envelope]);
+  }
+  /** `lyth_submitEncrypted` — submit a bincode-encoded encrypted envelope hex. */
+  async lythSubmitEncrypted(envelopeHex) {
+    return this.call("lyth_submitEncrypted", [envelopeHex]);
+  }
+  /** `lyth_getEncryptionKey` — cluster ML-KEM encapsulation key. */
+  async lythGetEncryptionKey() {
+    return this.call("lyth_getEncryptionKey", []);
+  }
+  /** `lyth_syncStatus` — DAG-sync driver snapshot. */
+  async lythSyncStatus() {
+    const v = await this.call("lyth_syncStatus", []);
+    if (v === null || v === void 0) return null;
+    return v;
+  }
+  /** `lyth_resolveOperatorAuthority` — operator id to authority index. */
+  async lythResolveOperatorAuthority(operatorId) {
+    return normalizeOperatorAuthority(
+      await this.call("lyth_resolveOperatorAuthority", [operatorId])
+    );
+  }
+  /** `lyth_signingActivity` — recent per-round signing participation. */
+  async lythSigningActivity(authorityIndex, limit) {
+    const params = limit == null ? [authorityIndex] : [authorityIndex, limit];
+    return normalizeSigningActivity(await this.call("lyth_signingActivity", params));
+  }
+  /** `lyth_upcomingDuties` — deterministic upcoming duty windows. */
+  async lythUpcomingDuties(authorityIndex, horizonRounds) {
+    const params = horizonRounds == null ? [authorityIndex] : [authorityIndex, horizonRounds];
+    return normalizeUpcomingDuties(await this.call("lyth_upcomingDuties", params));
+  }
+  /** `lyth_operatorRisk` — miss-rate and jail-status window. */
+  async lythOperatorRisk(authorityIndex, windowRounds) {
+    const params = windowRounds == null ? [authorityIndex] : [authorityIndex, windowRounds];
+    return normalizeOperatorRisk(await this.call("lyth_operatorRisk", params));
+  }
+  /** `lyth_upgradeStatus` — signed network-upgrade readiness at a height. */
+  async lythUpgradeStatus(block) {
+    const params = block === void 0 ? [] : [encodeBlockSelector(block)];
+    return this.call("lyth_upgradeStatus", params);
+  }
+  /** `lyth_runtimeProvenance` — public-safe build/runtime provenance. */
+  async lythRuntimeProvenance() {
+    return this.call("lyth_runtimeProvenance", []);
+  }
+  /** `lyth_txStatus` — discriminated transaction lookup outcome. */
+  async lythTxStatus(txHash) {
+    return this.call("lyth_txStatus", [txHash]);
+  }
+  /** `lyth_verticesAtRound` — per-vertex authorship observed at a DAG round. */
+  async lythVerticesAtRound(round) {
+    return this.call("lyth_verticesAtRound", [
+      encodeRpcU64Number(round, "round")
+    ]);
+  }
+  /** `lyth_metricsRange` — retained telemetry series when the node has them. */
+  async lythMetricsRange(selectors, range) {
+    const params = range === void 0 ? [selectors] : [
+      selectors,
+      range === null ? null : [
+        encodeRpcU64Number(range[0], "fromBlock"),
+        encodeRpcU64Number(range[1], "toBlock")
+      ]
+    ];
+    return this.call("lyth_metricsRange", params);
+  }
+  /** `lyth_getLatestCheckpoint` — latest PQ-finality checkpoint rows. */
+  async lythGetLatestCheckpoint(belowHeight) {
+    const params = belowHeight === void 0 ? [] : [encodeOptionalHeight(belowHeight)];
+    return this.call("lyth_getLatestCheckpoint", params);
+  }
+  /** `lyth_getClusterResignations` — in-flight + applied operator resignations. */
+  async lythGetClusterResignations(operator, status) {
+    const params = status === void 0 ? operator == null ? [] : [operator] : [operator ?? null, status];
+    return this.call("lyth_getClusterResignations", params);
+  }
+  /** `lyth_getBlsRoundCertificate` — round-advancement BLS aggregate. */
+  async lythGetBlsRoundCertificate(round) {
+    return this.call("lyth_getBlsRoundCertificate", [encodeRpcInteger(round)]);
+  }
+  /** `lyth_getLeaderCertificate` — leader-vote BLS aggregate for a block ref. */
+  async lythGetLeaderCertificate(round, authority, digest) {
+    return this.call("lyth_getLeaderCertificate", [encodeRpcInteger(round), authority, digest]);
+  }
+  /** `lyth_getDacCertificate` — data-availability certificate for a block ref. */
+  async lythGetDacCertificate(round, authority, digest) {
+    return this.call("lyth_getDacCertificate", [encodeRpcInteger(round), authority, digest]);
+  }
+  /** `lyth_subscribe` — WebSocket-only; returns an RPC error over HTTP. */
+  async lythSubscribe(channel) {
+    return this.call("lyth_subscribe", [channel]);
+  }
+  /** `lyth_unsubscribe` — counterpart to `lythSubscribe`. */
+  async lythUnsubscribe(subId) {
+    return this.call("lyth_unsubscribe", [subId]);
+  }
+  // ---- debug_* ------------------------------------------------------
+  // Server-side gated by `RpcConfig::debug_enabled`. When the namespace
+  // is disabled, every call surfaces as `SdkError.rpc`.
+  /** `debug_traceTransaction` — revm trace for a confirmed tx. */
+  async debugTraceTransaction(txHash) {
+    return this.call("debug_traceTransaction", [txHash]);
+  }
+  /** `debug_traceCall` — revm trace for a dry-run. */
+  async debugTraceCall(request, block = "latest") {
+    return this.call("debug_traceCall", [request, encodeBlockSelector(block)]);
+  }
+  /** `debug_traceBlockByNumber` — revm traces for an entire block. */
+  async debugTraceBlockByNumber(block) {
+    return this.call("debug_traceBlockByNumber", [encodeBlockSelector(block)]);
+  }
+  /** `debug_mempoolDump` — full mempool snapshot. */
+  async debugMempoolDump() {
+    return normalizeMempoolSnapshot(await this.call("debug_mempoolDump", []));
+  }
+  /** `debug_p2pPeers` — connected libp2p peer list. */
+  async debugP2pPeers() {
+    return this.call("debug_p2pPeers", []);
+  }
+  /** `debug_stateDiff` — state-diff for a block range. */
+  async debugStateDiff(params) {
+    return this.call("debug_stateDiff", params);
+  }
+  /** `debug_chainReorg` — testnet-only reorg trigger. */
+  async debugChainReorg(params) {
+    return this.call("debug_chainReorg", params);
+  }
+  // ---- mesh_* -------------------------------------------------------
+  /** `mesh_buildUnsignedTx` — build an unsigned transaction envelope. */
+  async meshBuildUnsignedTx(intent) {
+    return this.call("mesh_buildUnsignedTx", [intent]);
+  }
+  /** `mesh_combineTx` — combine an unsigned envelope with a wallet signature. */
+  async meshCombineTx(unsignedTx, signatureHex, algo, pubkeyHex) {
+    const params = algo === void 0 ? [unsignedTx, signatureHex] : pubkeyHex === void 0 ? [unsignedTx, signatureHex, algo] : [unsignedTx, signatureHex, algo, pubkeyHex];
+    return this.call("mesh_combineTx", params);
+  }
+  /** `mesh_decodeTx` — decode a signed or unsigned mesh envelope. */
+  async meshDecodeTx(envelopeHex, signed = false) {
+    return this.call("mesh_decodeTx", [envelopeHex, signed]);
+  }
+  /** `mesh_submitTx` — submit a signed mesh envelope. */
+  async meshSubmitTx(signedTx) {
+    return this.call("mesh_submitTx", [signedTx]);
+  }
+};
+function parseQuantityBig(hex) {
+  if (!hex) return 0n;
+  const rest = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+  if (rest.length === 0) return 0n;
+  if (!/^[0-9a-fA-F]+$/.test(rest)) {
+    throw SdkError.malformed(`invalid hex quantity: ${hex}`);
+  }
+  return BigInt(`0x${rest}`);
+}
+function parseQuantity(hex) {
+  const big = parseQuantityBig(hex);
+  if (big > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw SdkError.malformed(`hex quantity exceeds safe integer: ${hex}`);
+  }
+  return Number(big);
+}
+function encodeRpcInteger(v) {
+  if (typeof v === "bigint") return `0x${v.toString(16)}`;
+  return v;
+}
+function encodeOptionalHeight(v) {
+  if (v === null) return null;
+  return encodeRpcInteger(v);
+}
+function encodeRpcU64Number(v, label) {
+  return parseRpcNumber(v, label);
+}
+function parseRpcBigint(value, label) {
+  if (typeof value === "bigint") {
+    if (value < 0n) {
+      throw SdkError.malformed(`${label} must be a non-negative quantity`);
+    }
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw SdkError.malformed(`${label} must be a non-negative safe integer`);
+    }
+    return BigInt(value);
+  }
+  if (typeof value === "string") {
+    if (value.startsWith("0x") || value.startsWith("0X")) return parseQuantityBig(value);
+    if (/^\d+$/.test(value)) return BigInt(value);
+  }
+  throw SdkError.malformed(`${label} must be a bigint-compatible quantity`);
+}
+function parseRpcNumber(value, label) {
+  const big = parseRpcBigint(value, label);
+  if (big > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw SdkError.malformed(`${label} exceeds safe integer range`);
+  }
+  return Number(big);
+}
+function parseRpcNumberNullable(value, label) {
+  return value === null || value === void 0 ? null : parseRpcNumber(value, label);
+}
+function parseRpcBigintNullable(value, label) {
+  return value === null || value === void 0 ? null : parseRpcBigint(value, label);
+}
+function parseStringNullable(value) {
+  return value === null || value === void 0 ? null : String(value);
+}
+function expectObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw SdkError.malformed(`${label} must be an object`);
+  }
+  return value;
+}
+function normalizeServiceProbe(value) {
+  const row = expectObject(value, "service probe response");
+  return {
+    serviceMask: parseRpcNumber(row["serviceMask"], "service probe serviceMask"),
+    status: String(row["status"]),
+    statusCode: parseRpcNumber(row["statusCode"], "service probe statusCode"),
+    lastProbeBlock: parseRpcNumber(row["lastProbeBlock"], "service probe lastProbeBlock"),
+    latencyMs: parseRpcNumber(row["latencyMs"], "service probe latencyMs"),
+    probeDigest: String(row["probeDigest"]),
+    reporter: String(row["reporter"])
+  };
+}
+function assertSafeUint32(value, label) {
+  if (!Number.isInteger(value) || value < 0 || value > 4294967295) {
+    throw SdkError.malformed(`${label} must be a uint32`);
+  }
+}
+function assertHexBytes(value, expectedLen, label) {
+  const body = hexBody(value, label);
+  if (body.length !== expectedLen * 2) {
+    throw SdkError.malformed(`${label} must be ${expectedLen} bytes`);
+  }
+}
+function assertNonEmptyHex(value, label) {
+  const body = hexBody(value, label);
+  if (body.length === 0) {
+    throw SdkError.malformed(`${label} must be non-empty`);
+  }
+}
+function hexBody(value, label) {
+  const body = value.startsWith("0x") || value.startsWith("0X") ? value.slice(2) : value;
+  if (body.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(body)) {
+    throw SdkError.malformed(`${label} must be hex bytes`);
+  }
+  return body;
+}
+function normalizeOperatorInfo(value) {
+  const row = expectObject(value, "operator info response");
+  const activeClusterIds = row["activeClusterIds"];
+  if (!Array.isArray(activeClusterIds)) {
+    throw SdkError.malformed("operator info activeClusterIds must be an array");
+  }
+  const capability = row["capability"];
+  return {
+    operatorId: String(row["operatorId"]),
+    moniker: parseStringNullable(row["moniker"]),
+    alias: parseStringNullable(row["alias"]),
+    chainAddress: String(row["chainAddress"]),
+    bonded: Boolean(row["bonded"]),
+    commissionBps: parseRpcNumberNullable(row["commissionBps"], "operator info commissionBps"),
+    delegationCount: parseRpcNumberNullable(
+      row["delegationCount"],
+      "operator info delegationCount"
+    ),
+    bondedAmount: String(row["bondedAmount"]),
+    activeClusterIds: activeClusterIds.map(
+      (v, i) => parseRpcNumber(v, `operator info activeClusterIds[${i}]`)
+    ),
+    operatorKeyFingerprint: parseStringNullable(row["operatorKeyFingerprint"]),
+    blsKeyFingerprint: parseStringNullable(row["blsKeyFingerprint"]),
+    lifecycleState: String(row["lifecycleState"]),
+    capability: capability && typeof capability === "object" && !Array.isArray(capability) ? capability : {}
+  };
+}
+function normalizeClusterMember(value, label) {
+  const row = expectObject(value, label);
+  return {
+    operatorId: String(row["operatorId"]),
+    blsPubkey: String(row["blsPubkey"]),
+    state: String(row["state"])
+  };
+}
+function normalizeClusterStatus(value) {
+  const row = expectObject(value, "cluster status response");
+  const members = row["members"];
+  if (!Array.isArray(members)) {
+    throw SdkError.malformed("cluster status members must be an array");
+  }
+  return {
+    clusterId: parseRpcNumber(row["clusterId"], "cluster status clusterId"),
+    threshold: parseRpcNumber(row["threshold"], "cluster status threshold"),
+    size: parseRpcNumber(row["size"], "cluster status size"),
+    live: parseRpcNumber(row["live"], "cluster status live"),
+    lagging: parseRpcNumber(row["lagging"], "cluster status lagging"),
+    offline: parseRpcNumber(row["offline"], "cluster status offline"),
+    maintenance: parseRpcNumber(row["maintenance"], "cluster status maintenance"),
+    members: members.map((member, i) => normalizeClusterMember(member, `cluster status members[${i}]`)),
+    epoch: parseRpcBigintNullable(row["epoch"], "cluster status epoch"),
+    round: parseRpcBigintNullable(row["round"], "cluster status round"),
+    quorum: String(row["quorum"]),
+    reputationScore: parseRpcNumberNullable(
+      row["reputationScore"],
+      "cluster status reputationScore"
+    ),
+    livenessScore: parseRpcNumberNullable(row["livenessScore"], "cluster status livenessScore"),
+    lastUpdateHeight: parseRpcBigint(row["lastUpdateHeight"], "cluster status lastUpdateHeight")
+  };
+}
+function normalizeClusterDirectoryEntry(value, label) {
+  const row = expectObject(value, label);
+  const regionDiversity = row["regionDiversity"];
+  if (regionDiversity !== null && regionDiversity !== void 0 && !Array.isArray(regionDiversity)) {
+    throw SdkError.malformed(`${label}.regionDiversity must be an array or null`);
+  }
+  return {
+    clusterId: parseRpcNumber(row["clusterId"], `${label}.clusterId`),
+    size: parseRpcNumber(row["size"], `${label}.size`),
+    threshold: parseRpcNumber(row["threshold"], `${label}.threshold`),
+    aggregateHealth: String(row["aggregateHealth"]),
+    regionDiversity: Array.isArray(regionDiversity) ? regionDiversity.map(String) : null,
+    active: Boolean(row["active"])
+  };
+}
+function normalizeClusterDirectoryPage(value) {
+  const row = expectObject(value, "cluster directory response");
+  const clusters = row["clusters"];
+  if (!Array.isArray(clusters)) {
+    throw SdkError.malformed("cluster directory clusters must be an array");
+  }
+  return {
+    page: parseRpcNumber(row["page"], "cluster directory page"),
+    limit: parseRpcNumber(row["limit"], "cluster directory limit"),
+    totalClusters: parseRpcNumber(row["totalClusters"], "cluster directory totalClusters"),
+    clusters: clusters.map(
+      (cluster, i) => normalizeClusterDirectoryEntry(cluster, `cluster directory clusters[${i}]`)
+    )
+  };
+}
+function normalizeOperatorAuthority(value) {
+  const row = expectObject(value, "operator authority response");
+  return {
+    schemaVersion: parseRpcNumber(row["schemaVersion"], "operator authority schemaVersion"),
+    operatorId: String(row["operatorId"]),
+    authorityIndex: parseRpcNumber(row["authorityIndex"], "operator authority authorityIndex"),
+    blsPubkey: String(row["blsPubkey"]),
+    active: Boolean(row["active"])
+  };
+}
+function normalizeSigningActivity(value) {
+  const row = expectObject(value, "signing activity response");
+  const entries = row["entries"];
+  if (!Array.isArray(entries)) {
+    throw SdkError.malformed("signing activity entries must be an array");
+  }
+  return {
+    schemaVersion: parseRpcNumber(row["schemaVersion"], "signing activity schemaVersion"),
+    authorityIndex: parseRpcNumber(row["authorityIndex"], "signing activity authorityIndex"),
+    currentRound: parseRpcBigint(row["currentRound"], "signing activity currentRound"),
+    limit: parseRpcNumber(row["limit"], "signing activity limit"),
+    entries: entries.map((entry, i) => {
+      const e = expectObject(entry, `signing activity entries[${i}]`);
+      return {
+        round: parseRpcBigint(e["round"], `signing activity entries[${i}].round`),
+        status: String(e["status"])
+      };
+    })
+  };
+}
+function normalizeDutyAbsence(value, label) {
+  const row = expectObject(value, label);
+  return { reason: String(row["reason"]) };
+}
+function normalizeKeyRotationWindow(value) {
+  const row = expectObject(value, "upcoming duties keyRotation");
+  if ("nextRound" in row) {
+    return {
+      nextRound: parseRpcBigint(row["nextRound"], "upcoming duties keyRotation.nextRound"),
+      epochLengthRounds: parseRpcBigint(
+        row["epochLengthRounds"],
+        "upcoming duties keyRotation.epochLengthRounds"
+      )
+    };
+  }
+  return { reason: String(row["reason"]) };
+}
+function normalizeUpcomingDuties(value) {
+  const row = expectObject(value, "upcoming duties response");
+  const duties = expectObject(row["duties"], "upcoming duties duties");
+  const attestation = expectObject(duties["attestation"], "upcoming duties attestation");
+  return {
+    schemaVersion: parseRpcNumber(row["schemaVersion"], "upcoming duties schemaVersion"),
+    authorityIndex: parseRpcNumber(row["authorityIndex"], "upcoming duties authorityIndex"),
+    currentRound: parseRpcBigint(row["currentRound"], "upcoming duties currentRound"),
+    horizonRounds: parseRpcNumber(row["horizonRounds"], "upcoming duties horizonRounds"),
+    duties: {
+      attestation: {
+        startRound: parseRpcBigint(attestation["startRound"], "upcoming duties attestation.startRound"),
+        endRound: parseRpcBigint(attestation["endRound"], "upcoming duties attestation.endRound"),
+        kind: String(attestation["kind"])
+      },
+      blockProduction: normalizeDutyAbsence(
+        duties["blockProduction"],
+        "upcoming duties blockProduction"
+      ),
+      sync: normalizeDutyAbsence(duties["sync"], "upcoming duties sync"),
+      keyRotation: normalizeKeyRotationWindow(duties["keyRotation"])
+    }
+  };
+}
+function normalizeJailStatus(value) {
+  const row = expectObject(value, "operator risk jailStatus");
+  if ("jailed" in row || "tombstoned" in row) {
+    return {
+      jailed: Boolean(row["jailed"]),
+      tombstoned: Boolean(row["tombstoned"]),
+      jailedUntilHeight: parseRpcBigint(
+        row["jailedUntilHeight"],
+        "operator risk jailStatus.jailedUntilHeight"
+      ),
+      unjailCount: parseRpcBigint(row["unjailCount"], "operator risk jailStatus.unjailCount")
+    };
+  }
+  return { reason: String(row["reason"]) };
+}
+function normalizeOperatorRisk(value) {
+  const row = expectObject(value, "operator risk response");
+  const reasons = row["reasons"];
+  if (!Array.isArray(reasons)) {
+    throw SdkError.malformed("operator risk reasons must be an array");
+  }
+  return {
+    schemaVersion: parseRpcNumber(row["schemaVersion"], "operator risk schemaVersion"),
+    authorityIndex: parseRpcNumber(row["authorityIndex"], "operator risk authorityIndex"),
+    dataHeight: parseRpcBigint(row["dataHeight"], "operator risk dataHeight"),
+    windowRounds: parseRpcNumber(row["windowRounds"], "operator risk windowRounds"),
+    missedRounds: parseRpcNumber(row["missedRounds"], "operator risk missedRounds"),
+    observedRounds: parseRpcNumber(row["observedRounds"], "operator risk observedRounds"),
+    missRateBps: parseRpcNumber(row["missRateBps"], "operator risk missRateBps"),
+    thresholdBps: parseRpcNumber(row["thresholdBps"], "operator risk thresholdBps"),
+    remainingHeadroomBps: parseRpcNumber(
+      row["remainingHeadroomBps"],
+      "operator risk remainingHeadroomBps"
+    ),
+    jailStatus: normalizeJailStatus(row["jailStatus"]),
+    reasons: reasons.map(String)
+  };
+}
+function normalizeBlockHeader(value) {
+  if (value === null || value === void 0) return null;
+  if (!value || typeof value !== "object") {
+    throw SdkError.malformed("block header must be an object or null");
+  }
+  const h = value;
+  return {
+    number: parseRpcBigint(h["number"], "block header number"),
+    hash: String(h["hash"]),
+    parent_hash: String(h["parent_hash"]),
+    state_root: String(h["state_root"]),
+    timestamp: parseRpcBigint(h["timestamp"], "block header timestamp"),
+    gas_used: parseRpcBigint(h["gas_used"], "block header gas_used"),
+    gas_limit: parseRpcBigint(h["gas_limit"], "block header gas_limit")
+  };
+}
+function normalizeRoundInfo(value) {
+  if (!value || typeof value !== "object") {
+    throw SdkError.malformed("round info must be an object");
+  }
+  const row = value;
+  return {
+    height: parseRpcBigint(row["height"], "round height")
+  };
+}
+function normalizeMempoolSnapshot(value) {
+  if (!value || typeof value !== "object") {
+    throw SdkError.malformed("mempool snapshot must be an object");
+  }
+  const row = value;
+  const bytesByClass = row["bytes_by_class"];
+  if (!Array.isArray(bytesByClass) || bytesByClass.length !== 7) {
+    throw SdkError.malformed("mempool bytes_by_class must contain 7 entries");
+  }
+  return {
+    count_ready: parseRpcBigint(row["count_ready"], "mempool count_ready"),
+    count_pending: parseRpcBigint(row["count_pending"], "mempool count_pending"),
+    mailbox_depth: parseRpcBigint(row["mailbox_depth"], "mempool mailbox_depth"),
+    bytes_by_class: bytesByClass.map((v, i) => parseRpcBigint(v, `mempool bytes_by_class[${i}]`))
+  };
+}
+
+// src/address.ts
+var ADDRESS_HRP = "mono";
+var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var CHARSET_MAP = new Map([...CHARSET].map((c, i) => [c, i]));
+var BECH32M_CONST = 734539939;
+var HEX_20_BYTE_RE = /^0x[0-9a-fA-F]{40}$/;
+var AddressError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AddressError";
+  }
+};
+function hexToAddressBytes(address) {
+  if (!HEX_20_BYTE_RE.test(address)) {
+    throw new AddressError("expected 0x-prefixed 20-byte hex address");
+  }
+  const out = new Uint8Array(20);
+  const body = address.slice(2);
+  for (let i = 0; i < 20; i++) {
+    out[i] = Number.parseInt(body.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function addressBytesToHex(address) {
+  const bytes = expectLength2(address, 20, "address");
+  return `0x${[...bytes].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+function addressToBech32(address) {
+  const bytes = typeof address === "string" ? hexToAddressBytes(address) : expectLength2(address, 20, "address");
+  const words = convertBits([...bytes], 8, 5, true);
+  const checksum = createChecksum(ADDRESS_HRP, words);
+  return `${ADDRESS_HRP}1${[...words, ...checksum].map((v) => CHARSET[v]).join("")}`;
+}
+function bech32ToAddressBytes(address) {
+  const parsed = decodeBech32m(address);
+  if (parsed.hrp !== ADDRESS_HRP) {
+    throw new AddressError(`unexpected hrp '${parsed.hrp}', expected '${ADDRESS_HRP}'`);
+  }
+  const bytes = convertBits(parsed.data, 5, 8, false);
+  if (bytes.length !== 20) {
+    throw new AddressError(`expected 20-byte payload, got ${bytes.length} bytes`);
+  }
+  return Uint8Array.from(bytes);
+}
+function bech32ToAddress(address) {
+  return addressBytesToHex(bech32ToAddressBytes(address));
+}
+function parseAddress(address) {
+  if (address.startsWith("0x") || address.startsWith("0X")) {
+    return hexToAddressBytes(address);
+  }
+  return bech32ToAddressBytes(address);
+}
+function normalizeAddressHex(address) {
+  return addressBytesToHex(parseAddress(address));
+}
+function decodeBech32m(input) {
+  if (input.length < 8) {
+    throw new AddressError("bech32m address is too short");
+  }
+  const hasLower = input !== input.toUpperCase();
+  const hasUpper = input !== input.toLowerCase();
+  if (hasLower && hasUpper) {
+    throw new AddressError("bech32m address cannot mix upper and lower case");
+  }
+  const s = input.toLowerCase();
+  const sep = s.lastIndexOf("1");
+  if (sep <= 0 || sep + 7 > s.length) {
+    throw new AddressError("bech32m separator/checksum shape is invalid");
+  }
+  const hrp = s.slice(0, sep);
+  const values = [];
+  for (const c of s.slice(sep + 1)) {
+    const v = CHARSET_MAP.get(c);
+    if (v === void 0) {
+      throw new AddressError(`invalid bech32m character '${c}'`);
+    }
+    values.push(v);
+  }
+  if (!verifyChecksum(hrp, values)) {
+    throw new AddressError("bech32m checksum mismatch");
+  }
+  return { hrp, data: values.slice(0, -6) };
+}
+function hrpExpand(hrp) {
+  const high = [...hrp].map((c) => c.charCodeAt(0) >> 5);
+  const low = [...hrp].map((c) => c.charCodeAt(0) & 31);
+  return [...high, 0, ...low];
+}
+function polymod(values) {
+  const generators = [996825010, 642813549, 513874426, 1027748829, 705979059];
+  let chk = 1;
+  for (const value of values) {
+    const top = chk >> 25;
+    chk = (chk & 33554431) << 5 ^ value;
+    for (let i = 0; i < 5; i++) {
+      if ((top >> i & 1) === 1) {
+        chk ^= generators[i];
+      }
+    }
+  }
+  return chk >>> 0;
+}
+function createChecksum(hrp, data) {
+  const values = [...hrpExpand(hrp), ...data, 0, 0, 0, 0, 0, 0];
+  const mod = polymod(values) ^ BECH32M_CONST;
+  const out = [];
+  for (let p = 0; p < 6; p++) {
+    out.push(mod >> 5 * (5 - p) & 31);
+  }
+  return out;
+}
+function verifyChecksum(hrp, values) {
+  return polymod([...hrpExpand(hrp), ...values]) === BECH32M_CONST;
+}
+function convertBits(data, fromBits, toBits, pad) {
+  let acc = 0;
+  let bits = 0;
+  const ret = [];
+  const maxv = (1 << toBits) - 1;
+  const maxAcc = (1 << fromBits + toBits - 1) - 1;
+  for (const value of data) {
+    if (value < 0 || value >> fromBits !== 0) {
+      throw new AddressError("invalid address payload value");
+    }
+    acc = (acc << fromBits | value) & maxAcc;
+    bits += fromBits;
+    while (bits >= toBits) {
+      bits -= toBits;
+      ret.push(acc >> bits & maxv);
+    }
+  }
+  if (pad) {
+    if (bits > 0) {
+      ret.push(acc << toBits - bits & maxv);
+    }
+  } else if (bits >= fromBits || (acc << toBits - bits & maxv) !== 0) {
+    throw new AddressError("invalid bech32m padding");
+  }
+  return ret;
+}
+function expectLength2(value, len, name) {
+  if (value.length !== len) {
+    throw new AddressError(`${name} must be ${len} bytes`);
+  }
+  return value instanceof Uint8Array ? value : Uint8Array.from(value);
+}
+
+// src/spending-policy.ts
+var SET_POLICY_CLAIM_DOMAIN_TAG = "lyth.spending-policy.claim.v1";
+var ML_DSA_65_PUBLIC_KEY_LEN = 1952;
+var ML_DSA_65_SIGNATURE_LEN = 3309;
+var SPENDING_POLICY_SELECTORS = {
+  setPolicy: "0xd6a518b2",
+  setPolicyClaim: "0x08d78f9c",
+  claimPolicyByAddress: "0xc2397fe9",
+  enable: "0x5bfa1b68",
+  disable: "0xe6c09edf",
+  recordSpend: "0xdca04292"
+};
+var SpendingPolicyError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SpendingPolicyError";
+  }
+};
+function spendingPolicyAddressHex() {
+  return PRECOMPILE_ADDRESSES.SPENDING_POLICY.toLowerCase();
+}
+function composeClaimBoundMessage(chainId, args, opts) {
+  const precompileAddress = toAddressBytes(opts?.precompileAddress ?? PRECOMPILE_ADDRESSES.SPENDING_POLICY);
+  const normalized = normalizeArgs(args);
+  return concatBytes2(
+    new TextEncoder().encode(SET_POLICY_CLAIM_DOMAIN_TAG),
+    uint64Bytes(chainId, "chainId"),
+    precompileAddress,
+    normalized.subAccount,
+    normalized.principal,
+    uint128Bytes(normalized.dailyCapWei, "dailyCapWei"),
+    uint128Bytes(normalized.perTxCapWei, "perTxCapWei"),
+    normalized.allowRoot,
+    normalized.denyRoot,
+    uint64Bytes(opts?.expectedPolicyVersion ?? 0n, "expectedPolicyVersion")
+  );
+}
+function encodeSetPolicyCalldata(args) {
+  const normalized = normalizeArgs(args);
+  return bytesToHex2(
+    concatBytes2(
+      hexToBytes2(SPENDING_POLICY_SELECTORS.setPolicy),
+      encodePolicyWords(normalized)
+    )
+  );
+}
+function encodeSetPolicyClaimCalldata(args, subAccountPubkey, subAccountSig) {
+  const normalized = normalizeArgs(args);
+  const pubkey = toBytes2(subAccountPubkey);
+  const sig = toBytes2(subAccountSig);
+  if (pubkey.length !== ML_DSA_65_PUBLIC_KEY_LEN) {
+    throw new SpendingPolicyError(
+      `subAccountPubkey must be ${ML_DSA_65_PUBLIC_KEY_LEN} bytes, got ${pubkey.length}`
+    );
+  }
+  if (sig.length !== ML_DSA_65_SIGNATURE_LEN) {
+    throw new SpendingPolicyError(
+      `subAccountSig must be ${ML_DSA_65_SIGNATURE_LEN} bytes, got ${sig.length}`
+    );
+  }
+  return bytesToHex2(
+    concatBytes2(
+      hexToBytes2(SPENDING_POLICY_SELECTORS.setPolicyClaim),
+      encodePolicyWords(normalized),
+      pubkey,
+      sig
+    )
+  );
+}
+function encodeClaimPolicyByAddressCalldata(args, subAccountSig) {
+  const normalized = normalizeArgs(args);
+  const sig = toBytes2(subAccountSig);
+  if (sig.length !== ML_DSA_65_SIGNATURE_LEN) {
+    throw new SpendingPolicyError(
+      `subAccountSig must be ${ML_DSA_65_SIGNATURE_LEN} bytes, got ${sig.length}`
+    );
+  }
+  return bytesToHex2(
+    concatBytes2(
+      hexToBytes2(SPENDING_POLICY_SELECTORS.claimPolicyByAddress),
+      encodePolicyWords(normalized),
+      sig
+    )
+  );
+}
+function encodeEnableCalldata(subAccount) {
+  return encodeSingleAddressCall(SPENDING_POLICY_SELECTORS.enable, subAccount);
+}
+function encodeDisableCalldata(subAccount) {
+  return encodeSingleAddressCall(SPENDING_POLICY_SELECTORS.disable, subAccount);
+}
+function normalizeArgs(args) {
+  return {
+    subAccount: toAddressBytes(args.subAccount),
+    principal: toAddressBytes(args.principal),
+    dailyCapWei: toBigint(args.dailyCapWei, "dailyCapWei"),
+    perTxCapWei: toBigint(args.perTxCapWei, "perTxCapWei"),
+    allowRoot: expectLength3(toBytes2(args.allowRoot), 32, "allowRoot"),
+    denyRoot: expectLength3(toBytes2(args.denyRoot), 32, "denyRoot")
+  };
+}
+function encodePolicyWords(args) {
+  return concatBytes2(
+    encodeAddressWord(args.subAccount),
+    encodeAddressWord(args.principal),
+    encodeUint128Word(args.dailyCapWei),
+    encodeUint128Word(args.perTxCapWei),
+    args.allowRoot,
+    args.denyRoot
+  );
+}
+function encodeSingleAddressCall(selector, address) {
+  return bytesToHex2(concatBytes2(hexToBytes2(selector), encodeAddressWord(toAddressBytes(address))));
+}
+function encodeAddressWord(address) {
+  return concatBytes2(new Uint8Array(12), address);
+}
+function encodeUint128Word(value) {
+  return concatBytes2(new Uint8Array(16), uint128Bytes(value, "uint128"));
+}
+function toAddressBytes(value) {
+  if (typeof value === "string") {
+    return hexToAddressBytes(value);
+  }
+  return expectLength3(value instanceof Uint8Array ? value : Uint8Array.from(value), 20, "address");
+}
+function toBytes2(value) {
+  if (typeof value === "string") {
+    return hexToBytes2(value);
+  }
+  return value instanceof Uint8Array ? value : Uint8Array.from(value);
+}
+function hexToBytes2(hex) {
+  const body = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+  if (body.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(body)) {
+    throw new SpendingPolicyError("invalid hex bytes");
+  }
+  const out = new Uint8Array(body.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Number.parseInt(body.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function bytesToHex2(bytes) {
+  return `0x${[...bytes].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+function concatBytes2(...parts) {
+  const out = new Uint8Array(parts.reduce((acc, p) => acc + p.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function expectLength3(value, len, name) {
+  if (value.length !== len) {
+    throw new SpendingPolicyError(`${name} must be ${len} bytes`);
+  }
+  return value;
+}
+function toBigint(value, name) {
+  const n = typeof value === "bigint" ? value : BigInt(value);
+  if (n < 0n) {
+    throw new SpendingPolicyError(`${name} must be non-negative`);
+  }
+  return n;
+}
+function uint64Bytes(value, name) {
+  const n = toBigint(value, name);
+  if (n > 0xffffffffffffffffn) {
+    throw new SpendingPolicyError(`${name} exceeds uint64`);
+  }
+  return bigintBytes(n, 8);
+}
+function uint128Bytes(value, name) {
+  if (value > 0xffffffffffffffffffffffffffffffffn) {
+    throw new SpendingPolicyError(`${name} exceeds uint128`);
+  }
+  return bigintBytes(value, 16);
+}
+function bigintBytes(value, len) {
+  const out = new Uint8Array(len);
+  let n = value;
+  for (let i = len - 1; i >= 0; i--) {
+    out[i] = Number(n & 0xffn);
+    n >>= 8n;
+  }
+  return out;
+}
+
+// src/pubkey-registry.ts
+var PUBKEY_REGISTRY_ML_DSA_65_PUBLIC_KEY_LEN = 1952;
+var PUBKEY_REGISTRY_SELECTORS = {
+  registerPubkey: "0x5fe984e7",
+  lookupPubkey: "0x87c42001",
+  hasPubkey: "0x01c0d167"
+};
+var PubkeyRegistryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PubkeyRegistryError";
+  }
+};
+function pubkeyRegistryAddressHex() {
+  return PRECOMPILE_ADDRESSES.PUBKEY_REGISTRY.toLowerCase();
+}
+function encodeRegisterPubkeyCalldata(pubkey) {
+  const bytes = toBytes3(pubkey);
+  if (bytes.length !== PUBKEY_REGISTRY_ML_DSA_65_PUBLIC_KEY_LEN) {
+    throw new PubkeyRegistryError(
+      `pubkey must be ${PUBKEY_REGISTRY_ML_DSA_65_PUBLIC_KEY_LEN} bytes, got ${bytes.length}`
+    );
+  }
+  return bytesToHex3(
+    concatBytes3(
+      hexToBytes3(PUBKEY_REGISTRY_SELECTORS.registerPubkey),
+      uint256Word(32n),
+      uint256Word(BigInt(bytes.length)),
+      bytes
+    )
+  );
+}
+function encodeLookupPubkeyCalldata(address) {
+  return encodeSingleAddressCall2(PUBKEY_REGISTRY_SELECTORS.lookupPubkey, address);
+}
+function encodeHasPubkeyCalldata(address) {
+  return encodeSingleAddressCall2(PUBKEY_REGISTRY_SELECTORS.hasPubkey, address);
+}
+function decodeLookupPubkeyReturn(data) {
+  const bytes = toBytes3(data);
+  if (bytes.length < 96) {
+    throw new PubkeyRegistryError("lookup return must be at least 96 bytes");
+  }
+  const offset = wordToBigint(bytes.slice(0, 32));
+  if (offset !== 64n) {
+    throw new PubkeyRegistryError("lookup pubkey offset must be 0x40");
+  }
+  const setBlock = wordToBigint(bytes.slice(32, 64));
+  const len = wordToBigint(bytes.slice(Number(offset), Number(offset) + 32));
+  if (len > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new PubkeyRegistryError("pubkey length exceeds safe integer range");
+  }
+  const bodyLen = Number(len);
+  const bodyStart = Number(offset) + 32;
+  const padded = Math.ceil(bodyLen / 32) * 32;
+  if (bytes.length < bodyStart + padded) {
+    throw new PubkeyRegistryError("lookup return bytes body is truncated");
+  }
+  return {
+    pubkey: bytes.slice(bodyStart, bodyStart + bodyLen),
+    setBlock
+  };
+}
+function decodeHasPubkeyReturn(data) {
+  const bytes = toBytes3(data);
+  if (bytes.length !== 32) {
+    throw new PubkeyRegistryError("hasPubkey return must be 32 bytes");
+  }
+  for (let i = 0; i < 31; i++) {
+    if (bytes[i] !== 0) {
+      throw new PubkeyRegistryError("hasPubkey bool high bytes must be zero");
+    }
+  }
+  if (bytes[31] === 0) return false;
+  if (bytes[31] === 1) return true;
+  throw new PubkeyRegistryError("hasPubkey bool must be 0 or 1");
+}
+function encodeSingleAddressCall2(selector, address) {
+  return bytesToHex3(concatBytes3(hexToBytes3(selector), addressWord(toAddressBytes2(address))));
+}
+function addressWord(address) {
+  return concatBytes3(new Uint8Array(12), address);
+}
+function toAddressBytes2(value) {
+  if (typeof value === "string") {
+    return hexToAddressBytes(value);
+  }
+  return expectLength4(value instanceof Uint8Array ? value : Uint8Array.from(value), 20, "address");
+}
+function toBytes3(value) {
+  if (typeof value === "string") {
+    return hexToBytes3(value);
+  }
+  return value instanceof Uint8Array ? value : Uint8Array.from(value);
+}
+function hexToBytes3(hex) {
+  const body = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+  if (body.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(body)) {
+    throw new PubkeyRegistryError("invalid hex bytes");
+  }
+  const out = new Uint8Array(body.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = Number.parseInt(body.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
+function bytesToHex3(bytes) {
+  return `0x${[...bytes].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+function concatBytes3(...parts) {
+  const out = new Uint8Array(parts.reduce((acc, p) => acc + p.length, 0));
+  let offset = 0;
+  for (const part of parts) {
+    out.set(part, offset);
+    offset += part.length;
+  }
+  return out;
+}
+function expectLength4(value, len, name) {
+  if (value.length !== len) {
+    throw new PubkeyRegistryError(`${name} must be ${len} bytes`);
+  }
+  return value;
+}
+function uint256Word(value) {
+  if (value < 0n || value > (1n << 256n) - 1n) {
+    throw new PubkeyRegistryError("uint256 value out of range");
+  }
+  const out = new Uint8Array(32);
+  let n = value;
+  for (let i = 31; i >= 0; i--) {
+    out[i] = Number(n & 0xffn);
+    n >>= 8n;
+  }
+  return out;
+}
+function wordToBigint(word) {
+  if (word.length !== 32) {
+    throw new PubkeyRegistryError("ABI word must be 32 bytes");
+  }
+  let out = 0n;
+  for (const b of word) {
+    out = out << 8n | BigInt(b);
+  }
+  return out;
+}
+
+// src/ethers/network.ts
+var MONOLYTHIUM_TESTNET_CHAIN_ID = 69420n;
+var MONOLYTHIUM_TESTNET_NETWORK_NAME = "monolythium-testnet";
+var MONOLYTHIUM_NETWORKS = {
+  testnet: {
+    chainId: MONOLYTHIUM_TESTNET_CHAIN_ID,
+    name: MONOLYTHIUM_TESTNET_NETWORK_NAME
+  }
+};
+
+// src/ethers/provider.ts
+var MonolythiumProvider = class extends JsonRpcApiProvider {
+  /** Underlying SDK client. Exposed for callers that want native types. */
+  rpcClient;
+  constructor(endpointOrClient, options = {}) {
+    const network = options.network ?? {
+      chainId: MONOLYTHIUM_TESTNET_CHAIN_ID,
+      name: MONOLYTHIUM_TESTNET_NETWORK_NAME
+    };
+    try {
+      Network.register(
+        network.name,
+        () => new Network(network.name, network.chainId)
+      );
+    } catch (_e) {
+    }
+    super(new Network(network.name, network.chainId));
+    this.rpcClient = typeof endpointOrClient === "string" ? new RpcClient(endpointOrClient, {
+      fetch: options.fetch,
+      headers: options.headers
+    }) : endpointOrClient;
+  }
+  /**
+   * Forward a single JSON-RPC method through the SDK transport. Ethers'
+   * `_perform` calls this and ethers callers can also call `provider.send`
+   * directly to access methods the rich provider interface does not wrap
+   * (e.g. `lyth_*`).
+   */
+  async _send(payload) {
+    const calls = Array.isArray(payload) ? payload : [payload];
+    return Promise.all(calls.map((p) => this.#sendOne(p)));
+  }
+  async #sendOne(p) {
+    try {
+      const params = Array.isArray(p.params) ? p.params : p.params === void 0 ? [] : p.params;
+      const result = await this.rpcClient.call(p.method, params);
+      return { id: p.id, result };
+    } catch (e) {
+      if (e instanceof SdkError && e.kind === "rpc") {
+        return {
+          id: p.id,
+          error: {
+            code: e.code ?? -32603,
+            message: e.message,
+            data: e.data
+          }
+        };
+      }
+      const msg = e?.message ?? String(e);
+      return {
+        id: p.id,
+        error: { code: -32603, message: `${msg}` }
+      };
+    }
+  }
+};
+var MonolythiumSigner = class _MonolythiumSigner extends AbstractSigner {
+  #backend;
+  constructor(backend, provider) {
+    super(provider ?? null);
+    this.#backend = backend;
+  }
+  /**
+   * Wrap any ethers v6 `BaseWallet` (the parent class of `Wallet`,
+   * `HDNodeWallet`, and friends) so callers don't have to write a
+   * `MonolythiumSignerBackend` for the common test / dev path.
+   *
+   * Both `new Wallet(privateKey)` and `Wallet.createRandom()` /
+   * `HDNodeWallet.fromMnemonic(...)` are accepted.
+   */
+  static fromEthersWallet(wallet, provider) {
+    const backend = {
+      getAddress: async () => wallet.address,
+      signTransaction: (tx) => wallet.signTransaction(tx),
+      signMessage: (message) => wallet.signMessage(message),
+      signTypedData: (domain, types, value) => wallet.signTypedData(domain, types, value)
+    };
+    return new _MonolythiumSigner(backend, provider);
+  }
+  async getAddress() {
+    return this.#backend.getAddress();
+  }
+  connect(provider) {
+    return new _MonolythiumSigner(this.#backend, provider);
+  }
+  async signTransaction(tx) {
+    return this.#backend.signTransaction(tx);
+  }
+  async signMessage(message) {
+    return this.#backend.signMessage(message);
+  }
+  async signTypedData(domain, types, value) {
+    return this.#backend.signTypedData(domain, types, value);
+  }
+};
+
+// src/ethers/tx-translate.ts
+function toHexQuantity(v) {
+  if (v === null || v === void 0) return void 0;
+  if (typeof v === "string") {
+    if (v.startsWith("0x") || v.startsWith("0X")) return v;
+    return `0x${BigInt(v).toString(16)}`;
+  }
+  if (typeof v === "number") return `0x${v.toString(16)}`;
+  return `0x${v.toString(16)}`;
+}
+function translateTxIn(req) {
+  const out = {};
+  if (req.from !== void 0 && req.from !== null) out.from = req.from;
+  if (req.to !== void 0 && req.to !== null) out.to = req.to;
+  const gas = toHexQuantity(req.gasLimit);
+  if (gas !== void 0) out.gas = gas;
+  const gasPrice = toHexQuantity(req.gasPrice);
+  if (gasPrice !== void 0) out.gasPrice = gasPrice;
+  const value = toHexQuantity(req.value);
+  if (value !== void 0) out.value = value;
+  if (req.data !== void 0 && req.data !== null) out.data = req.data;
+  return out;
+}
+function translateReceiptOut(monoReceipt, fromAddress, toAddress) {
+  return {
+    transactionHash: monoReceipt.tx_hash,
+    blockHash: monoReceipt.block_hash,
+    blockNumber: `0x${BigInt(monoReceipt.block_number).toString(16)}`,
+    transactionIndex: `0x${monoReceipt.tx_index.toString(16)}`,
+    status: monoReceipt.status === 1 ? "0x1" : "0x0",
+    gasUsed: `0x${BigInt(monoReceipt.gas_used).toString(16)}`,
+    cumulativeGasUsed: `0x${BigInt(monoReceipt.gas_used).toString(16)}`,
+    effectiveGasPrice: "0x0",
+    contractAddress: null,
+    from: fromAddress ?? "0x0000000000000000000000000000000000000000",
+    to: toAddress,
+    type: "0x2",
+    logsBloom: `0x${"0".repeat(512)}`,
+    logs: []
+  };
+}
+function translateBlockOut(header) {
+  return {
+    number: `0x${header.number.toString(16)}`,
+    hash: header.hash,
+    parentHash: header.parent_hash,
+    timestamp: `0x${header.timestamp.toString(16)}`,
+    gasUsed: `0x${header.gas_used.toString(16)}`,
+    gasLimit: `0x${header.gas_limit.toString(16)}`,
+    stateRoot: header.state_root,
+    miner: "0x0000000000000000000000000000000000000000",
+    difficulty: "0x0",
+    nonce: "0x0000000000000000",
+    baseFeePerGas: null,
+    extraData: "0x",
+    mixHash: "0x0000000000000000000000000000000000000000000000000000000000000000",
+    transactions: [],
+    transactionsRoot: "0x0000000000000000000000000000000000000000000000000000000000000000",
+    receiptsRoot: "0x0000000000000000000000000000000000000000000000000000000000000000",
+    logsBloom: `0x${"0".repeat(512)}`,
+    sha3Uncles: "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+    uncles: [],
+    size: "0x0"
+  };
+}
+
+// src/index.ts
+var version = "0.1.0";
+
+export { ADDRESS_HRP, AddressError, ApiClient, BURN_ADDR, CHAIN_REGISTRY, CHAIN_REGISTRY_RAW_BASE, ML_DSA_65_PUBLIC_KEY_LEN, ML_DSA_65_SIGNATURE_LEN, MONOLYTHIUM_NETWORKS, MONOLYTHIUM_TESTNET_CHAIN_ID, MONOLYTHIUM_TESTNET_NETWORK_NAME, MonolythiumProvider, MonolythiumSigner, NODE_REGISTRY_CAPABILITIES, NODE_REGISTRY_CAPABILITY_MASK, NODE_REGISTRY_PUBLIC_SERVICE_MASK, NODE_REGISTRY_SELECTORS, NodeRegistryError, PRECOMPILE_ADDRESSES, PUBKEY_REGISTRY_ML_DSA_65_PUBLIC_KEY_LEN, PUBKEY_REGISTRY_SELECTORS, PubkeyRegistryError, RpcClient, SERVICE_PROBE_STATUS, SET_POLICY_CLAIM_DOMAIN_TAG, SPENDING_POLICY_SELECTORS, SdkError, SpendingPolicyError, TESTNET_69420, addressBytesToHex, addressToBech32, apiEndpointFromRpcEndpoint, bech32ToAddress, bech32ToAddressBytes, composeClaimBoundMessage, decodeHasPubkeyReturn, decodeLookupPubkeyReturn, encodeBlockSelector, encodeClaimPolicyByAddressCalldata, encodeDisableCalldata, encodeEnableCalldata, encodeHasPubkeyCalldata, encodeLookupPubkeyCalldata, encodeRegisterPubkeyCalldata, encodeReportServiceProbeCalldata, encodeSetPolicyCalldata, encodeSetPolicyClaimCalldata, fetchChainInfoLatest, fetchChainRegistryLatest, getChainInfo, getP2pSeeds, getRpcEndpoints, hexToAddressBytes, isConcreteServiceProbeStatus, isSinglePublicServiceProbeMask, isValidNodeRegistryCapabilities, isValidPublicServiceProbeMask, nodeRegistryAddressHex, normalizeAddressHex, parseAddress, parseChainRegistryToml, parseQuantity, parseQuantityBig, pubkeyRegistryAddressHex, serviceProbeStatusLabel, spendingPolicyAddressHex, translateBlockOut, translateReceiptOut, translateTxIn, version };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map