@asentum/sdk 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,444 +1,1471 @@
+// src/internal/crypto.ts
+import { ml_dsa65 } from "@noble/post-quantum/ml-dsa";
+import { blake3 as nobleBlake3 } from "@noble/hashes/blake3";
+var DILITHIUM3_SEED_BYTES = 32;
+var DILITHIUM3_PUBLIC_KEY_BYTES = 1952;
+var DILITHIUM3_SIGNATURE_BYTES = 3309;
+var ADDRESS_BYTES = 20;
+var ASE_HRP = "ase";
+function generateKeypair(seed) {
+  let s = seed;
+  if (!s) {
+    s = new Uint8Array(DILITHIUM3_SEED_BYTES);
+    globalThis.crypto.getRandomValues(s);
+  }
+  if (s.length !== DILITHIUM3_SEED_BYTES) {
+    throw new Error(`Dilithium3 seed must be ${DILITHIUM3_SEED_BYTES} bytes, got ${s.length}`);
+  }
+  const keys = ml_dsa65.keygen(s);
+  return { publicKey: keys.publicKey, secretKey: keys.secretKey };
+}
+function sign(message, secretKey) {
+  return ml_dsa65.sign(secretKey, message);
+}
+function blake3(data, dkLen = 32) {
+  return nobleBlake3(data, { dkLen });
+}
+function addressBytesFromPublicKey(publicKey) {
+  return blake3(publicKey).slice(0, ADDRESS_BYTES);
+}
+var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
+function polymod(values) {
+  let chk = 1;
+  for (const v of values) {
+    const top = chk >> 25;
+    chk = (chk & 33554431) << 5 ^ v;
+    for (let i = 0; i < 5; i++) if (top >> i & 1) chk ^= GENERATOR[i];
+  }
+  return chk;
+}
+function hrpExpand(hrp) {
+  const ret = [];
+  for (let i = 0; i < hrp.length; i++) ret.push(hrp.charCodeAt(i) >> 5);
+  ret.push(0);
+  for (let i = 0; i < hrp.length; i++) ret.push(hrp.charCodeAt(i) & 31);
+  return ret;
+}
+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 (let i = 0; i < data.length; i++) {
+    const value = data[i];
+    if (value < 0 || value >> fromBits !== 0) return null;
+    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) {
+    return null;
+  }
+  return ret;
+}
+function bech32Encode(hrp, bytes) {
+  const data = convertBits(bytes, 8, 5, true);
+  if (!data) throw new Error("bech32: convertBits failed on encode");
+  const values = hrpExpand(hrp).concat(data).concat([0, 0, 0, 0, 0, 0]);
+  const mod = polymod(values) ^ 1;
+  let out = `${hrp}1`;
+  for (const d of data) out += CHARSET.charAt(d);
+  for (let p = 0; p < 6; p++) out += CHARSET.charAt(mod >> 5 * (5 - p) & 31);
+  return out;
+}
+function bech32Decode(input) {
+  if (typeof input !== "string" || input.length < 8 || input.length > 90) return null;
+  const lower = input.toLowerCase();
+  if (input !== lower && input !== input.toUpperCase()) return null;
+  const sep = lower.lastIndexOf("1");
+  if (sep < 1 || sep + 7 > lower.length) return null;
+  const hrp = lower.slice(0, sep);
+  const data = [];
+  for (const c of lower.slice(sep + 1)) {
+    const v = CHARSET.indexOf(c);
+    if (v < 0) return null;
+    data.push(v);
+  }
+  if (polymod(hrpExpand(hrp).concat(data)) !== 1) return null;
+  const payload = convertBits(data.slice(0, -6), 5, 8, false);
+  if (!payload) return null;
+  return { hrp, bytes: new Uint8Array(payload) };
+}
+function bytesToHex(bytes) {
+  let hex = "0x";
+  for (let i = 0; i < bytes.length; i++) hex += (bytes[i] ?? 0).toString(16).padStart(2, "0");
+  return hex;
+}
+function hexToBytes(hex) {
+  const h = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+  if (h.length % 2 !== 0) throw new Error("invalid hex: odd number of characters");
+  if (!/^[0-9a-fA-F]*$/.test(h)) throw new Error("invalid hex: non-hex character");
+  const out = new Uint8Array(h.length / 2);
+  for (let i = 0; i < out.length; i++) out[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+
+// src/ase1.ts
+var HEX_ADDR = /^0x[0-9a-fA-F]{40}$/;
+function ase1ToHexOrNull(s) {
+  if (typeof s !== "string") return null;
+  if (s.length < 4 || s.slice(0, 4).toLowerCase() !== `${ASE_HRP}1`) return null;
+  const decoded = bech32Decode(s);
+  if (!decoded || decoded.hrp !== ASE_HRP || decoded.bytes.length !== ADDRESS_BYTES) return null;
+  return bytesToHex(decoded.bytes);
+}
+function ase1ToHex(s) {
+  return ase1ToHexOrNull(s);
+}
+function isAse1(s) {
+  return typeof s === "string" && ase1ToHexOrNull(s) !== null;
+}
+function isHexAddress(s) {
+  return typeof s === "string" && HEX_ADDR.test(s);
+}
+function isAddress(s) {
+  return isAse1(s) || isHexAddress(s);
+}
+function hexToAse1(hex) {
+  if (!isHexAddress(hex)) return "";
+  return bech32Encode(ASE_HRP, addressToBytes(hex));
+}
+function toAse1(a) {
+  if (a === null || a === void 0) return "";
+  const s = String(a).trim();
+  if (isHexAddress(s)) return hexToAse1(s);
+  if (isAse1(s)) return s.toLowerCase();
+  return s;
+}
+function toHexAddress(a) {
+  return bytesToHex(addressToBytes(a));
+}
+function addressToBytes(a) {
+  if (typeof a !== "string" || a.trim() === "") throw new Error("invalid address: empty");
+  const s = a.trim();
+  if (isHexAddress(s)) {
+    const out = new Uint8Array(ADDRESS_BYTES);
+    for (let i = 0; i < ADDRESS_BYTES; i++) out[i] = parseInt(s.slice(2 + i * 2, 4 + i * 2), 16);
+    return out;
+  }
+  const hex = ase1ToHexOrNull(s);
+  if (hex) return addressToBytes(hex);
+  throw new Error(`invalid address: "${s.length > 14 ? s.slice(0, 14) + "..." : s}" (expected ase1... or 0x + 40 hex)`);
+}
+function bytesToAse1(bytes) {
+  if (bytes.length !== ADDRESS_BYTES) throw new Error(`address must be ${ADDRESS_BYTES} bytes, got ${bytes.length}`);
+  return bech32Encode(ASE_HRP, bytes);
+}
+function shortAse1(a, lead = 10, tail = 6) {
+  const s = toAse1(a);
+  return s.length > lead + tail ? `${s.slice(0, lead)}...${s.slice(-tail)}` : s;
+}
+function maybeAse1(v) {
+  return typeof v === "string" && isHexAddress(v) ? hexToAse1(v) : v;
+}
+function isPlainObject(v) {
+  if (v === null || typeof v !== "object") return false;
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+}
+function ase1ArgsToHex(value) {
+  if (typeof value === "string") {
+    return ase1ToHexOrNull(value) ?? value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((v) => ase1ArgsToHex(v));
+  }
+  if (isPlainObject(value)) {
+    const out = {};
+    for (const k of Object.keys(value)) out[k] = ase1ArgsToHex(value[k]);
+    return out;
+  }
+  return value;
+}
+
+// src/errors.ts
+var AsentumError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "AsentumError";
+    this.code = code;
+    if (options && "cause" in options) this.cause = options.cause;
+  }
+};
+var HttpError = class extends AsentumError {
+  status;
+  url;
+  /** Parsed JSON body when there was one, otherwise the text (the gateway sends HTML for 429). */
+  body;
+  constructor(status, url, body, message, code = "HTTP_ERROR") {
+    const detail = body && typeof body === "object" && "error" in body ? `: ${String(body.error)}` : "";
+    super(code, message ?? `HTTP ${status} from ${url}${detail}`);
+    this.name = "HttpError";
+    this.status = status;
+    this.url = url;
+    this.body = body;
+  }
+};
+var RateLimitError = class extends HttpError {
+  /** From the Retry-After header, when the server sent one. */
+  retryAfterMs;
+  constructor(url, body, retryAfterMs) {
+    super(429, url, body, `rate limited (HTTP 429) by ${url}${retryAfterMs ? `, retry after ${retryAfterMs} ms` : ""}`, "RATE_LIMITED");
+    this.name = "RateLimitError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+var NetworkError = class extends AsentumError {
+  url;
+  constructor(url, cause) {
+    super("NETWORK_ERROR", `network error calling ${url}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    this.name = "NetworkError";
+    this.url = url;
+  }
+};
+var RpcError = class extends AsentumError {
+  path;
+  body;
+  constructor(path, message, body) {
+    super("RPC_ERROR", `${path}: ${message}`);
+    this.name = "RpcError";
+    this.path = path;
+    this.body = body;
+  }
+};
+var JsonRpcError = class extends AsentumError {
+  rpcCode;
+  method;
+  data;
+  constructor(method, rpcCode, message, data) {
+    super("JSON_RPC_ERROR", `JSON-RPC ${method} failed (${rpcCode}): ${message}`);
+    this.name = "JsonRpcError";
+    this.method = method;
+    this.rpcCode = rpcCode;
+    this.data = data;
+  }
+};
+var TxRejectedError = class extends AsentumError {
+  reason;
+  /** The locally computed hash of the rejected transaction (it is not on chain). */
+  txHash;
+  constructor(reason, txHash) {
+    super("TX_REJECTED", `transaction rejected: ${reason || "unknown reason"}`);
+    this.name = "TxRejectedError";
+    this.reason = reason || "unknown reason";
+    this.txHash = txHash;
+  }
+  /** True when the reason is about the nonce (stale, too far ahead, duplicate nonce). */
+  get isNonceError() {
+    return /nonce/i.test(this.reason);
+  }
+};
+var TxFailedError = class extends AsentumError {
+  receipt;
+  constructor(receipt) {
+    super("TX_FAILED", receipt.error ? `transaction failed on chain: ${receipt.error}` : "transaction failed on chain");
+    this.name = "TxFailedError";
+    this.receipt = receipt;
+  }
+};
+var TimeoutError = class extends AsentumError {
+  txHash;
+  lastReceipt;
+  constructor(txHash, timeoutMs, until, lastReceipt) {
+    super(
+      "TIMEOUT",
+      lastReceipt ? `transaction ${txHash} is in block ${lastReceipt.blockNumber} but was not final within ${timeoutMs} ms` : `transaction ${txHash} not ${until === "final" ? "final" : "in a block"} within ${timeoutMs} ms; it may still go through, check it on the explorer before sending again`
+    );
+    this.name = "TimeoutError";
+    this.txHash = txHash;
+    this.lastReceipt = lastReceipt;
+  }
+};
+var AbortError = class extends AsentumError {
+  constructor(message = "aborted") {
+    super("ABORTED", message);
+    this.name = "AbortError";
+  }
+};
+var ViewError = class extends AsentumError {
+  method;
+  reason;
+  constructor(method, reason) {
+    super("VIEW_FAILED", `view call ${method}() failed: ${reason || "unknown"}`);
+    this.name = "ViewError";
+    this.method = method;
+    this.reason = reason || "unknown";
+  }
+};
+
+// src/http.ts
+var IN_BROWSER = typeof globalThis.document !== "undefined";
+function sleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) return reject(new AbortError());
+    const t = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    const onAbort = () => {
+      clearTimeout(t);
+      reject(new AbortError());
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function parseRetryAfter(h) {
+  if (!h) return void 0;
+  const secs = Number(h);
+  if (Number.isFinite(secs) && secs >= 0) return secs * 1e3;
+  const date = Date.parse(h);
+  if (!Number.isNaN(date)) return Math.max(0, date - Date.now());
+  return void 0;
+}
+var Transport = class {
+  baseUrl;
+  fetchImpl;
+  retries;
+  timeoutMs;
+  baseMs;
+  maxMs;
+  headers;
+  constructor(baseUrl, opts = {}) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    this.fetchImpl = opts.fetch ?? ((input, init) => globalThis.fetch(input, init));
+    this.retries = opts.retries ?? 3;
+    this.timeoutMs = opts.requestTimeoutMs ?? 3e4;
+    this.baseMs = opts.backoffBaseMs ?? 500;
+    this.maxMs = opts.backoffMaxMs ?? 1e4;
+    this.headers = opts.headers ?? {};
+  }
+  backoffDelay(attempt, retryAfterMs) {
+    if (retryAfterMs !== void 0) return Math.min(this.maxMs, Math.max(retryAfterMs, 0));
+    const exp = Math.min(this.maxMs, this.baseMs * 2 ** attempt);
+    return Math.round(exp * (0.75 + Math.random() * 0.5));
+  }
+  async request(path, opts = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const method = opts.method ?? (opts.body === void 0 ? "GET" : "POST");
+    const retries = opts.retries ?? this.retries;
+    const retryOnServerError = opts.retryOnServerError ?? true;
+    for (let attempt = 0; ; attempt++) {
+      if (opts.signal?.aborted) throw new AbortError();
+      let res;
+      const ctrl = new AbortController();
+      const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+      const onAbort = () => ctrl.abort();
+      opts.signal?.addEventListener("abort", onAbort, { once: true });
+      try {
+        const headers = { accept: "application/json", ...this.headers };
+        if (opts.body !== void 0) headers["content-type"] = "application/json";
+        const init = {
+          method,
+          headers,
+          body: opts.body === void 0 ? void 0 : JSON.stringify(opts.body),
+          signal: ctrl.signal
+        };
+        if (IN_BROWSER) init.cache = "no-store";
+        res = await this.fetchImpl(url, init);
+      } catch (err) {
+        clearTimeout(timer);
+        opts.signal?.removeEventListener("abort", onAbort);
+        if (opts.signal?.aborted) throw new AbortError();
+        if (retryOnServerError && attempt < retries) {
+          await sleep(this.backoffDelay(attempt), opts.signal);
+          continue;
+        }
+        throw new NetworkError(url, err);
+      }
+      clearTimeout(timer);
+      opts.signal?.removeEventListener("abort", onAbort);
+      const body = await readBody(res);
+      if (res.ok || opts.allowStatus?.includes(res.status)) {
+        return { status: res.status, body, headers: res.headers };
+      }
+      const retryAfterMs = parseRetryAfter(res.headers?.get?.("retry-after") ?? null);
+      const serverHiccup = res.status === 502 || res.status === 503 || res.status === 504 || res.status === 500 && typeof body === "string";
+      const retryable = res.status === 429 || retryOnServerError && serverHiccup;
+      if (retryable && attempt < retries) {
+        await sleep(this.backoffDelay(attempt, retryAfterMs), opts.signal);
+        continue;
+      }
+      if (res.status === 429) throw new RateLimitError(url, body, retryAfterMs);
+      throw new HttpError(res.status, url, body);
+    }
+  }
+};
+async function readBody(res) {
+  let text;
+  try {
+    text = await res.text();
+  } catch {
+    return null;
+  }
+  if (text === "") return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+
 // src/client.ts
+var DEFAULT_RPC = "https://testnet.asentum.com";
+var GOVERNANCE_CONTRACT = hexToAse1("0x0000000000000000000000000000000000000003");
+var MAX_LOG_RANGE = 1e4;
+function asRecord(v) {
+  return v !== null && typeof v === "object" && !Array.isArray(v) ? v : null;
+}
+function errorField(body) {
+  const r = asRecord(body);
+  if (!r || r.error === void 0 || r.error === null || r.error === "") return null;
+  const msg = r.message ? `${String(r.error)} (${String(r.message)})` : String(r.error);
+  return msg;
+}
+function normReceipt(r) {
+  return { ...r, sender: maybeAse1(r.sender), recipient: maybeAse1(r.recipient) };
+}
+function normTx(t) {
+  const out = { ...t, body: { ...t.body, to: maybeAse1(t.body?.to) } };
+  if (t.sender) out.sender = maybeAse1(t.sender);
+  return out;
+}
+function normBlock(b) {
+  return {
+    ...b,
+    header: { ...b.header, proposer: maybeAse1(b.header.proposer) },
+    transactions: (b.transactions ?? []).map(normTx),
+    receipts: (b.receipts ?? []).map(normReceipt)
+  };
+}
+function toBlockParam(v) {
+  if (v === void 0) return void 0;
+  if (typeof v === "number" || typeof v === "bigint") return "0x" + BigInt(v).toString(16);
+  if (/^\d+$/.test(v)) return "0x" + BigInt(v).toString(16);
+  return v;
+}
+function hexToUtf8(hex) {
+  return new TextDecoder().decode(hexToBytes(hex));
+}
+function eventTopic(name) {
+  return bytesToHex(blake3(new TextEncoder().encode(name)));
+}
+function hidden() {
+  const d = globalThis.document;
+  return !!d && d.visibilityState === "hidden";
+}
 var AsentumClient = class {
   rpcUrl;
-  constructor(rpcUrl) {
-    this.rpcUrl = rpcUrl.replace(/\/$/, "");
+  /** @internal */
+  transport;
+  chainIdCache;
+  constructor(rpcUrl = DEFAULT_RPC, options = {}) {
+    this.rpcUrl = rpcUrl.replace(/\/+$/, "");
+    this.transport = new Transport(this.rpcUrl, options);
   }
   // ---------------------------------------------------------------------------
-  // Chain reads
+  // Chain and health
   // ---------------------------------------------------------------------------
-  /** Get chain info including the latest block header. */
-  async getChainInfo() {
-    const raw = await this.get("/chain");
-    return { ...raw, height: Number(BigInt(raw.height)) };
-  }
-  /** Get the current block height. */
-  async getBlockNumber() {
-    const info = await this.getChainInfo();
-    return info.height;
-  }
-  /** Get the chain ID as a bigint. */
-  async getChainId() {
-    const info = await this.getChainInfo();
-    return BigInt(info.chainId);
-  }
-  /** Get a block by number, including transactions and receipts. */
-  async getBlock(number) {
-    try {
-      return await this.get(`/block/${number}`);
-    } catch {
-      return null;
-    }
+  /** Finalized height and tip in one small call (GET /v3/heads). */
+  async getHeads(opts = {}) {
+    const r = await this.get("/v3/heads", opts);
+    return { finalized: Number(r.finalized), tip: Number(r.tip) };
   }
-  /** Get the balance and nonce for an address. */
-  async getBalance(address) {
-    return this.get(`/balance/${address}`);
+  /** Newest block height on the best chain. */
+  async getTipNumber(opts = {}) {
+    return (await this.getHeads(opts)).tip;
   }
-  /** Get the nonce for an address (shorthand for getBalance().nonce). */
-  async getNonce(address) {
-    const bal = await this.getBalance(address);
-    return BigInt(bal.nonce);
+  /** Finalized height (same as eth_blockNumber and getBlockNumber). */
+  async getFinalizedNumber(opts = {}) {
+    return (await this.getHeads(opts)).finalized;
   }
-  /** Get the receipt for a transaction by hash. */
-  async getReceipt(txHash) {
-    try {
-      const r = await this.get(`/receipts/${txHash}`);
-      if (r && typeof r === "object" && "error" in r) return null;
-      return r;
-    } catch {
-      return null;
-    }
+  /** Chain id, finalized height, this node's mempool size and the finalized header (GET /chain, cached 1 s on the gateway). */
+  async getChainInfo(opts = {}) {
+    const raw = await this.get("/chain", opts);
+    return {
+      ...raw,
+      height: Number(raw.height),
+      latestHeader: { ...raw.latestHeader, proposer: maybeAse1(raw.latestHeader?.proposer) }
+    };
   }
-  /** Get the source code of a deployed contract (hex-encoded). */
-  async getCode(address) {
-    const res = await this.jsonRpc("eth_getCode", [address, "latest"]);
-    return res;
-  }
-  /** Get the source code of a deployed contract as a UTF-8 string. */
-  async getContractSource(address) {
-    const hex = await this.getCode(address);
-    if (!hex || hex === "0x" || hex.length <= 2) return null;
-    const raw = hex.startsWith("0x") ? hex.slice(2) : hex;
-    const bytes = new Uint8Array(raw.length / 2);
-    for (let i = 0; i < bytes.length; i++) {
-      bytes[i] = parseInt(raw.substr(i * 2, 2), 16);
+  /** The FINALIZED height. Use getTipNumber() for the newest block. */
+  async getBlockNumber(opts = {}) {
+    return (await this.getChainInfo(opts)).height;
+  }
+  /** Chain id (1423 on the public testnet). Cached after the first call. */
+  async getChainId(opts = {}) {
+    if (this.chainIdCache === void 0) {
+      this.chainIdCache = BigInt((await this.getChainInfo(opts)).chainId);
     }
-    return new TextDecoder().decode(bytes);
+    return this.chainIdCache;
   }
-  /** Call a contract view function (read-only, no transaction). */
-  async viewCall(contract, method, args = []) {
-    return this.post("/view", { contract, method, args });
+  /** Chain details in EIP-3085 shape (GET /metadata, cached 30 s on the gateway). */
+  async getMetadata(opts = {}) {
+    return this.get("/metadata", opts);
   }
-  /** Get the current active validator set. */
-  async getValidators() {
-    return this.get("/validators");
+  /** Node identity (GET /api). `version` is a fixed placeholder, not the node release. */
+  async getApiInfo(opts = {}) {
+    const r = await this.get("/api", opts);
+    return { ...r, faucetAddress: r.faucetAddress ? maybeAse1(r.faucetAddress) : r.faucetAddress };
   }
-  /** Get the chain metadata (EIP-3085 shape). */
-  async getMetadata() {
-    return this.get("/metadata");
+  /** The genesis spec (GET /genesis, about 17 KB). Address fields converted to ase1. */
+  async getGenesis(opts = {}) {
+    const r = await this.getChecked("/genesis", opts);
+    const fix = (list) => Array.isArray(list) ? list.map((e) => {
+      const o = asRecord(e);
+      if (!o) return e;
+      const c = { ...o };
+      for (const k of Object.keys(c)) if (/address$/i.test(k)) c[k] = maybeAse1(c[k]);
+      return c;
+    }) : list;
+    return { ...r, initialAccounts: fix(r.initialAccounts), initialValidators: fix(r.initialValidators), initialAseHolders: fix(r.initialAseHolders) };
   }
-  /** Health check. */
-  async isHealthy() {
+  /** Liveness probe (GET /health). True as long as the HTTP server answers. Does not check sync. */
+  async isHealthy(opts = {}) {
     try {
-      const res = await this.get("/health");
-      return res.status === "ok";
-    } catch {
+      const res = await this.get("/health", { ...opts, retries: opts.retries ?? 0 });
+      return res?.status === "ok";
+    } catch (err) {
+      if (err instanceof AbortError) throw err;
       return false;
     }
   }
-  /** Readiness check (chain advancing). */
-  async isReady() {
+  /**
+   * Readiness probe (GET /ready): true on 200 "ready", false on 503 "stale"
+   * or no answer. Caveat: node 0.8.1 compares seconds with milliseconds
+   * here, so it reports ready even on a stalled node. To detect a stall,
+   * check that getHeads() keeps moving.
+   */
+  async isReady(opts = {}) {
     try {
-      await fetch(`${this.rpcUrl}/ready`);
-      return true;
-    } catch {
+      const r = await this.transport.request("/ready", {
+        signal: opts.signal,
+        retries: opts.retries ?? 0,
+        allowStatus: [503]
+      });
+      return r.status === 200 && r.body?.status === "ready";
+    } catch (err) {
+      if (err instanceof AbortError) throw err;
       return false;
     }
   }
-  /** Request test ASE from the faucet. */
-  async faucet(to, amount = "100000000000000000000") {
-    return this.post("/dev/faucet", { to, amount });
+  // ---------------------------------------------------------------------------
+  // Accounts
+  // ---------------------------------------------------------------------------
+  /** Balance (wei), nonce and pendingNonce at the tip (GET /balance). */
+  async getBalance(address, opts = {}) {
+    const r = await this.getChecked(`/balance/${encodeURIComponent(address)}`, opts);
+    return { ...r, address: maybeAse1(r.address) };
+  }
+  /**
+   * The nonce to SEND with. Default: the node's mempool-aware pendingNonce,
+   * so several sends in a row get n, n+1, n+2. `{ pending: false }` gives
+   * the account nonce at the tip.
+   */
+  async getNonce(address, opts = {}) {
+    const bal = await this.getBalance(address, opts);
+    return BigInt(opts.pending === false ? bal.nonce : bal.pendingNonce ?? bal.nonce);
   }
-  /** Submit a raw signed transaction (hex-encoded SSZ bytes). */
-  async submitRawTx(rawTxHex) {
-    return this.post("/tx", { rawTx: rawTxHex });
+  /** Full account record: balance, nonce, codeHash, storageRoot (GET /asentum/account). */
+  async getAccount(address, opts = {}) {
+    const r = await this.getChecked(`/asentum/account/${encodeURIComponent(address)}`, opts);
+    return { ...r, address: maybeAse1(r.address) };
+  }
+  /** Whether the chain has this account's public key on record, so it may send key-less transactions (GET /public-key). */
+  async getPublicKeyStatus(address, opts = {}) {
+    const r = await this.getChecked(`/public-key/${encodeURIComponent(address)}`, opts);
+    return { ...r, address: maybeAse1(r.address) };
   }
   // ---------------------------------------------------------------------------
-  // Ethereum JSON-RPC (subset)
+  // Blocks
   // ---------------------------------------------------------------------------
-  /** Send a raw JSON-RPC request. */
-  async jsonRpc(method, params = []) {
-    const res = await fetch(`${this.rpcUrl}/`, {
+  /**
+   * A block with decoded transactions and receipts, or null when this node
+   * does not have it. Finalized blocks only, unless `{ tip: true }`.
+   * (0.1.x returned the node's error object here instead of null.)
+   */
+  async getBlock(number, opts = {}) {
+    const q = opts.tip ? "?tip=1" : "";
+    const r = await this.get(`/block/${BigInt(number)}${q}`, opts);
+    const err = errorField(r);
+    if (err) {
+      if (/not found/i.test(err)) return null;
+      throw new RpcError(`/block/${number}`, err, r);
+    }
+    return normBlock(r);
+  }
+  /** Only the receipts of a block (GET /block/<n>/receipts). Check `available` before trusting an empty list. */
+  async getBlockReceipts(number, opts = {}) {
+    const q = opts.tip ? "?tip=1" : "";
+    const r = await this.getChecked(`/block/${BigInt(number)}/receipts${q}`, opts);
+    return { ...r, receipts: (r.receipts ?? []).map(normReceipt), available: r.finalized !== void 0 };
+  }
+  /** The block as SSZ bytes (0x hex), or null. Note: also serves pending heights without saying so. */
+  async getRawBlock(number, opts = {}) {
+    const r = await this.get(`/block-raw/${BigInt(number)}`, opts);
+    if (errorField(r)) return null;
+    return r.bytes ?? null;
+  }
+  /** Whether a height is finalized on this node, and the Aura hash finalized there (GET /v3/finalized). */
+  async getFinalizedStatus(height, opts = {}) {
+    return this.getChecked(`/v3/finalized?height=${BigInt(height)}`, opts);
+  }
+  // ---------------------------------------------------------------------------
+  // Transactions and receipts
+  // ---------------------------------------------------------------------------
+  /**
+   * The receipt of a transaction, or null when it is not in a block (yet).
+   * Tip receipts are included by default (finalized: false); see
+   * `finalizedOnly`. Check `success`, not `status`.
+   *
+   * Throws RpcError for a malformed hash and HttpError / NetworkError after
+   * retries (0.1.x returned null for every error).
+   */
+  async getReceipt(txHash, opts = {}) {
+    const q = opts.finalizedOnly ? "?tip=0" : "";
+    const r = await this.get(`/receipts/${encodeURIComponent(txHash)}${q}`, opts);
+    const rec = asRecord(r);
+    if (rec && rec.blockNumber !== void 0 && rec.blockNumber !== null) return normReceipt(r);
+    const err = errorField(r);
+    if (!err || /receipt not found/i.test(err)) return null;
+    throw new RpcError(`/receipts/${txHash}`, err, r);
+  }
+  /** The transaction body from eth_getTransactionByHash (in-block transactions only, tip too), or null. */
+  async getTransaction(txHash, opts = {}) {
+    const t = await this.jsonRpc("eth_getTransactionByHash", [txHash], opts);
+    if (!t) return null;
+    return { ...t, from: toAse1(t.from), to: t.to ? toAse1(t.to) : null };
+  }
+  /**
+   * Submit one signed transaction (POST /tx). Does not throw on rejection:
+   * check `accepted`. `accepted: true` only means "in this node's mempool".
+   */
+  async submitRawTx(rawTxHex, opts = {}) {
+    const r = await this.transport.request("/tx", {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
+      body: { rawTx: rawTxHex },
+      signal: opts.signal,
+      retries: opts.retries,
+      retryOnServerError: false
     });
-    if (!res.ok) throw new Error(`JSON-RPC ${method} failed: ${res.status}`);
-    const body = await res.json();
-    if (body.error) throw new Error(`JSON-RPC error: ${body.error.message}`);
-    return body.result;
+    return r.body;
+  }
+  /**
+   * Submit several signed transactions in one request (POST /tx/batch).
+   * They are admitted in order; one rejection does not stop the rest.
+   */
+  async submitRawTxBatch(rawTxs, opts = {}) {
+    if (rawTxs.length === 0) return { accepted: 0, rejected: 0, total: 0, results: [] };
+    const r = await this.transport.request("/tx/batch", {
+      method: "POST",
+      body: { transactions: rawTxs.map((rawTx) => ({ rawTx })) },
+      signal: opts.signal,
+      retries: opts.retries,
+      retryOnServerError: false
+    });
+    return r.body;
+  }
+  /**
+   * Wait for a transaction's receipt. Polls GET /receipts about once a
+   * second, backs off on 429 / 5xx, and follows the receipt through a
+   * reorg (onReorg, then onIncluded again for the new block).
+   *
+   * Resolves with the receipt (until: "included", the default) or with the
+   * final receipt (until: "final"). Rejects with TimeoutError (not a
+   * failure: the tx may still land), AbortError, or TxFailedError when
+   * throwOnFailure is set.
+   */
+  async waitForReceipt(txHash, opts = {}) {
+    const until = opts.until ?? "included";
+    const timeoutMs = opts.timeoutMs ?? (until === "final" ? 12e4 : 6e4);
+    const interval = opts.pollIntervalMs ?? 1e3;
+    const pause = opts.pauseWhenHidden ?? true;
+    const deadline = Date.now() + timeoutMs;
+    let seen = null;
+    let delay = interval;
+    while (Date.now() < deadline) {
+      if (opts.signal?.aborted) throw new AbortError();
+      if (pause && hidden()) {
+        await sleep(Math.min(1e3, Math.max(0, deadline - Date.now())), opts.signal);
+        continue;
+      }
+      let r = null;
+      let polled = false;
+      try {
+        r = await this.getReceipt(txHash, { signal: opts.signal, retries: 0 });
+        polled = true;
+        delay = interval;
+      } catch (err) {
+        if (err instanceof AbortError || err instanceof RpcError) throw err;
+        if (err instanceof RateLimitError) {
+          delay = Math.min(1e4, err.retryAfterMs ?? delay * 2);
+        } else if (err instanceof NetworkError || err instanceof HttpError && err.status >= 500) {
+          delay = Math.min(1e4, delay * 2);
+        } else {
+          throw err;
+        }
+      }
+      if (polled) {
+        if (r) {
+          if (seen && seen.blockHash && r.blockHash && seen.blockHash !== r.blockHash) {
+            opts.onReorg?.(seen);
+            seen = null;
+          }
+          if (!seen) {
+            seen = r;
+            opts.onIncluded?.(r);
+          } else {
+            seen = r;
+          }
+          const isFinal = r.finalized !== false;
+          if (until === "included" || isFinal) {
+            if (r.success === false && opts.throwOnFailure) throw new TxFailedError(r);
+            if (until === "final") opts.onFinal?.(r);
+            return r;
+          }
+        } else if (seen) {
+          opts.onReorg?.(seen);
+          seen = null;
+        }
+      }
+      const left = deadline - Date.now();
+      if (left <= 0) break;
+      await sleep(Math.min(delay, left), opts.signal);
+    }
+    throw new TimeoutError(txHash, timeoutMs, until, seen);
   }
   // ---------------------------------------------------------------------------
-  // Internal HTTP helpers
+  // Contracts
+  // ---------------------------------------------------------------------------
+  /**
+   * Run a contract method read-only (POST /view). ase1 addresses inside
+   * `args` are converted to 0x hex first (the node does not convert them,
+   * and contracts store accounts as hex). Reads the tip unless
+   * `{ blockTag: 'finalized' }`. Does not throw on ok: false; see view().
+   */
+  async viewCall(contract, method, args = [], opts = {}) {
+    const body = { contract, method, args: ase1ArgsToHex(args) };
+    if (opts.blockTag) body.blockTag = opts.blockTag;
+    const r = await this.transport.request("/view", {
+      method: "POST",
+      body,
+      signal: opts.signal,
+      retries: opts.retries
+    });
+    return r.body;
+  }
+  /** Like viewCall, but returns the method's return value and throws ViewError on ok: false. */
+  async view(contract, method, args = [], opts = {}) {
+    const r = await this.viewCall(contract, method, args, opts);
+    if (!r.ok) throw new ViewError(method, r.reason ?? "unknown");
+    return r.returnValue;
+  }
+  /** A contract's source, hex-encoded UTF-8 (eth_getCode). "0x" for an account without code. */
+  async getCode(address, opts = {}) {
+    return this.jsonRpc("eth_getCode", [address, "latest"], opts);
+  }
+  /** A contract's JavaScript source as text, or null when the address has no code. */
+  async getContractSource(address, opts = {}) {
+    const hex = await this.getCode(address, opts);
+    if (!hex || hex === "0x") return null;
+    return hexToUtf8(hex);
+  }
+  /** A contract storage value by key (a plain string such as "self"), as text, or null when empty (eth_getStorageAt). */
+  async getStorageAt(address, key, opts = {}) {
+    const hex = await this.jsonRpc("eth_getStorageAt", [address, key, "latest"], opts);
+    if (!hex || hex === "0x") return null;
+    return hexToUtf8(hex);
+  }
+  /**
+   * Contract events from eth_getLogs, decoded. Finalized blocks only. A
+   * range wider than 10,000 blocks is split into several calls.
+   *
+   *   await client.getLogs({ address: 'ase1...', event: 'Transfer', fromBlock: 570000, toBlock: 571000 })
+   */
+  async getLogs(filter = {}, opts = {}) {
+    const topics = filter.event ? [eventTopic(filter.event)] : filter.topics;
+    const address = filter.address;
+    const from = filter.fromBlock;
+    const to = filter.toBlock;
+    const numeric = (v) => typeof v === "number" || typeof v === "bigint" || typeof v === "string" && /^\d+$/.test(v);
+    const ranges = [];
+    if (numeric(from) && numeric(to)) {
+      let a = BigInt(from);
+      const b = BigInt(to);
+      if (a > b) return [];
+      while (a <= b) {
+        const end = a + BigInt(MAX_LOG_RANGE) - 1n < b ? a + BigInt(MAX_LOG_RANGE) - 1n : b;
+        ranges.push([toBlockParam(a), toBlockParam(end)]);
+        a = end + 1n;
+      }
+    } else {
+      ranges.push([toBlockParam(from), toBlockParam(to)]);
+    }
+    const out = [];
+    for (const [fromBlock, toBlock] of ranges) {
+      const params = {};
+      if (fromBlock !== void 0) params.fromBlock = fromBlock;
+      if (toBlock !== void 0) params.toBlock = toBlock;
+      if (address !== void 0) params.address = address;
+      if (topics !== void 0) params.topics = topics;
+      const logs = await this.jsonRpc("eth_getLogs", [params], opts);
+      for (const l of logs ?? []) {
+        const raw = String(l.data ?? "0x");
+        let data = null;
+        if (raw !== "0x") {
+          const text = hexToUtf8(raw);
+          try {
+            data = JSON.parse(text);
+          } catch {
+            data = text;
+          }
+        }
+        const ts = l.topics ?? [];
+        out.push({
+          address: toAse1(String(l.address)),
+          topic: ts[0] ?? "",
+          topics: ts,
+          ...filter.event ? { eventName: filter.event } : {},
+          data,
+          rawData: raw,
+          blockNumber: Number(l.blockNumber),
+          blockHash: String(l.blockHash),
+          transactionHash: String(l.transactionHash),
+          transactionIndex: Number(l.transactionIndex),
+          logIndex: Number(l.logIndex),
+          removed: Boolean(l.removed)
+        });
+      }
+    }
+    return out;
+  }
+  // ---------------------------------------------------------------------------
+  // Validators and consensus
+  // ---------------------------------------------------------------------------
+  /** Every bonded validator with stake and committee state, plus the epoch (GET /validators, about 260 KB). */
+  async getValidators(opts = {}) {
+    const r = await this.getChecked("/validators", opts);
+    return {
+      ...r,
+      stakingContract: r.stakingContract ? maybeAse1(r.stakingContract) : r.stakingContract,
+      validators: (r.validators ?? []).map((v) => ({ ...v, address: maybeAse1(v.address) }))
+    };
+  }
+  /** Who signed recent blocks (GET /participation). lookback 1 to 10,000, default 1,000. */
+  async getParticipation(opts = {}) {
+    const q = opts.lookback !== void 0 ? `?lookback=${opts.lookback}` : "";
+    const r = await this.getChecked(`/participation${q}`, opts);
+    return { ...r, validators: (r.validators ?? []).map((v) => ({ ...v, address: maybeAse1(v.address) })) };
+  }
+  /** The voting committee of an epoch (default: current), ase1, in canonical order (GET /v3/committee). */
+  async getCommittee(opts = {}) {
+    const q = opts.epoch !== void 0 ? `?epoch=${BigInt(opts.epoch)}` : "";
+    const r = await this.getChecked(`/v3/committee${q}`, { ...opts, allowStatus: [404] });
+    return { ...r, committee: (r.committee ?? []).map(maybeAse1), leaderBase: (r.leaderBase ?? []).map(maybeAse1) };
+  }
+  /** The node's liveness tracker (GET /consensus/liveness, about 40 KB). */
+  async getLiveness(opts = {}) {
+    const r = await this.getChecked("/consensus/liveness", opts);
+    return {
+      ...r,
+      baked: (r.baked ?? []).map(maybeAse1),
+      tracked: (r.tracked ?? []).map((t) => ({ ...t, address: maybeAse1(t.address) }))
+    };
+  }
+  /** Slashed and tombstoned validators (GET /slashing/tombstones). */
+  async getTombstones(opts = {}) {
+    const r = await this.getChecked("/slashing/tombstones", opts);
+    return { ...r, slashingContract: maybeAse1(r.slashingContract) };
+  }
+  // ---------------------------------------------------------------------------
+  // Governance (reads; voting and proposing are contract calls)
+  // ---------------------------------------------------------------------------
+  /** The newest proposals, up to 50 (GET /governance/proposals). */
+  async getProposals(opts = {}) {
+    const r = await this.getChecked("/governance/proposals", opts);
+    return (r.proposals ?? []).map((p) => ({ ...p, proposer: maybeAse1(p.proposer) }));
+  }
+  /** One proposal with its amendments, or null for an unknown id (GET /governance/proposal/<id>). */
+  async getProposal(id, opts = {}) {
+    const r = await this.getChecked(
+      `/governance/proposal/${encodeURIComponent(String(id))}`,
+      opts
+    );
+    if (!r.proposal) return null;
+    const amendments = (r.amendments ?? []).map((a) => {
+      const o = asRecord(a);
+      if (!o) return a;
+      const c = { ...o };
+      for (const k of ["proposer", "author", "sender"]) if (k in c) c[k] = maybeAse1(c[k]);
+      return c;
+    });
+    return { proposal: { ...r.proposal, proposer: maybeAse1(r.proposal.proposer) }, amendments };
+  }
+  /** ASE (wei) an address has locked in governance votes (GET /governance/locked). */
+  async getGovernanceLocked(address, opts = {}) {
+    const r = await this.getChecked(`/governance/locked/${encodeURIComponent(address)}`, opts);
+    return { ...r, address: toAse1(r.address ?? address) };
+  }
+  /** Vote weight still locked vs ready to withdraw (GET /governance/withdrawable). */
+  async getGovernanceWithdrawable(address, opts = {}) {
+    const r = await this.getChecked(`/governance/withdrawable/${encodeURIComponent(address)}`, opts);
+    return { ...r, address: toAse1(r.address ?? address) };
+  }
+  /** Approved libraries (GET /governance/libraries). Library approval is disabled, so always empty today. */
+  async getGovernanceLibraries(opts = {}) {
+    return (await this.getChecked("/governance/libraries", opts)).libraries ?? [];
+  }
+  /** One approved library by name, or null (GET /governance/library/<name>). */
+  async getGovernanceLibrary(name, opts = {}) {
+    return (await this.getChecked(`/governance/library/${encodeURIComponent(name)}`, opts)).library ?? null;
+  }
+  // ---------------------------------------------------------------------------
+  // Dev faucet (devnets only)
   // ---------------------------------------------------------------------------
-  async get(path) {
-    const res = await fetch(`${this.rpcUrl}${path}`);
-    if (!res.ok) throw new Error(`GET ${path} failed: ${res.status} ${res.statusText}`);
-    return await res.json();
+  /**
+   * @deprecated The node's POST /dev/faucet is OFF unless the operator sets
+   * ASENTUM_DEV_FAUCET=1, which only makes sense on a local devnet. Every
+   * public node answers `{ accepted: false, reason: "faucet not enabled on
+   * this node" }`. For test ASE use the airdrop dashboard (see the docs page
+   * "Get Test ASE"). Kept for local devnets; never throws on 404 / 429.
+   */
+  async faucet(to, amount = "100000000000000000000", opts = {}) {
+    const r = await this.transport.request("/dev/faucet", {
+      method: "POST",
+      body: { to, amount },
+      signal: opts.signal,
+      retries: 0,
+      retryOnServerError: false,
+      allowStatus: [404, 410, 429]
+    });
+    const b = asRecord(r.body);
+    if (!b || typeof b.accepted !== "boolean") {
+      return { accepted: false, reason: `faucet not available on this node (HTTP ${r.status})` };
+    }
+    return r.body;
   }
-  async post(path, body) {
-    const res = await fetch(`${this.rpcUrl}${path}`, {
+  // ---------------------------------------------------------------------------
+  // JSON-RPC
+  // ---------------------------------------------------------------------------
+  /** Send one Ethereum-style JSON-RPC request to POST /. Throws JsonRpcError on an error object. */
+  async jsonRpc(method, params = [], opts = {}) {
+    const r = await this.transport.request("/", {
       method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(body)
+      body: { jsonrpc: "2.0", id: 1, method, params },
+      signal: opts.signal,
+      retries: opts.retries
     });
-    if (!res.ok) throw new Error(`POST ${path} failed: ${res.status} ${res.statusText}`);
-    return await res.json();
+    const body = asRecord(r.body);
+    if (!body) throw new AsentumError("JSON_RPC_ERROR", `JSON-RPC ${method}: unexpected response`);
+    const e = asRecord(body.error);
+    if (e) throw new JsonRpcError(method, Number(e.code ?? 0), String(e.message ?? "error"), e.data);
+    return body.result;
+  }
+  // ---------------------------------------------------------------------------
+  // Internal HTTP helpers
+  // ---------------------------------------------------------------------------
+  /** GET and return the body as is. */
+  async get(path, opts = {}) {
+    const r = await this.transport.request(path, { signal: opts.signal, retries: opts.retries, allowStatus: opts.allowStatus });
+    return r.body;
+  }
+  /** GET and throw RpcError when the body carries an `error` field (the node's HTTP 200 errors). */
+  async getChecked(path, opts = {}) {
+    const body = await this.get(path, opts);
+    const err = errorField(body);
+    if (err) throw new RpcError(path.split("?")[0], err, body);
+    if (body === null || typeof body !== "object") throw new RpcError(path, "unexpected non-JSON response", body);
+    return body;
   }
 };
 
-// src/wallet.ts
-import {
-  generateKeypair,
-  addressFromPublicKey
-} from "@asentum/crypto";
-import {
-  SignedTransactionSchema,
-  TransactionBodySchema
-} from "@asentum/types";
-import { blake3, sign } from "@asentum/crypto";
-
 // src/contract.ts
 var AsentumContract = class _AsentumContract {
   client;
+  /** ase1. (0.1.x kept whatever was passed in; a deploy gave 0x hex.) */
   address;
-  /** The deploy tx, if this contract was deployed in this session. */
+  /** Lowercase 0x hex, what other contracts and msg.sender comparisons use. */
+  addressHex;
+  /** The deploy transaction, when this contract was deployed in this session. */
   deployTx;
-  /** The wallet used to deploy this contract, if any. Used as default signer for send(). */
   wallet;
   constructor(client, address, deployTx, wallet) {
     this.client = client;
-    this.address = address;
+    this.addressHex = toHexAddress(address);
+    this.address = toAse1(this.addressHex);
     this.deployTx = deployTx;
     this.wallet = wallet;
   }
-  /**
-   * Call a view function (read-only, free, no transaction).
-   *
-   * @param method - The function name to call.
-   * @param args   - Arguments to pass to the function.
-   * @returns The return value of the function.
-   */
-  async view(method, args = []) {
-    const result = await this.client.viewCall(this.address, method, args);
-    if (!result.ok) {
-      throw new Error(`view call ${method}() failed: ${result.reason || "unknown"}`);
-    }
+  /** Call a view method (free, no transaction) and return its value. Throws ViewError on ok: false. */
+  async view(method, args = [], opts = {}) {
+    const result = await this.client.viewCall(this.address, method, args, opts);
+    if (!result.ok) throw new ViewError(method, result.reason ?? "unknown");
     return result.returnValue;
   }
-  /**
-   * Call a view function and return the full result including gas + events.
-   */
-  async viewFull(method, args = []) {
-    return this.client.viewCall(this.address, method, args);
+  /** Call a view method and return the full result: value, gas, events, blockNumber, finalized. */
+  async viewFull(method, args = [], opts = {}) {
+    return this.client.viewCall(this.address, method, args, opts);
   }
-  /**
-   * Send a state-changing transaction to the contract.
-   *
-   * @param method  - The function name to call.
-   * @param args    - Arguments to pass.
-   * @param opts    - Optional: value to attach, gas limit, nonce, wallet override.
-   * @returns A SentTx with `.hash` and `.wait()`.
-   */
+  /** Send a state-changing call. Needs a wallet (connect() or opts.wallet). */
   async send(method, args = [], opts = {}) {
     const signer = opts.wallet ?? this.wallet;
     if (!signer) {
-      throw new Error(
-        "no wallet available \u2014 pass a wallet in opts or create the contract via wallet.deploy()"
-      );
+      throw new AsentumError("INVALID_ARGUMENT", "no wallet available: pass opts.wallet or use contract.connect(wallet)");
     }
     return signer.sendCall({
       to: this.address,
       method,
       args,
       value: opts.value,
+      valueWei: opts.valueWei,
       gasLimit: opts.gasLimit,
-      nonce: opts.nonce
+      nonce: opts.nonce,
+      signal: opts.signal
     });
   }
-  /**
-   * Attach a wallet to this contract for future send() calls.
-   */
+  /** A copy of this contract that signs with `wallet`. */
   connect(wallet) {
     return new _AsentumContract(this.client, this.address, this.deployTx, wallet);
   }
-  /**
-   * Get the source code of this contract as a UTF-8 string.
-   * Returns null if the address has no deployed code.
-   */
-  async getSource() {
-    return this.client.getContractSource(this.address);
+  /** The contract's JavaScript source, or null if the address has no code. */
+  async getSource(opts = {}) {
+    return this.client.getContractSource(this.address, opts);
+  }
+  /** The contract's ASE balance in wei. */
+  async getBalance(opts = {}) {
+    return BigInt((await this.client.getBalance(this.address, opts)).balance);
+  }
+  /** The account record (codeHash = BLAKE3 of the source, storageRoot). */
+  async getAccount(opts = {}) {
+    return this.client.getAccount(this.address, opts);
   }
   /**
-   * Get the ASE balance of this contract.
+   * Events this contract emitted, decoded (eth_getLogs, finalized blocks
+   * only, ranges over 10,000 blocks are split). `eventName` undefined = all.
    */
-  async getBalance() {
-    const bal = await this.client.getBalance(this.address);
-    return BigInt(bal.balance);
+  async getEvents(eventName, range = {}, opts = {}) {
+    return this.client.getLogs({ address: this.address, event: eventName, ...range }, opts);
   }
   /**
-   * Wait for the deploy transaction to be confirmed (if this contract
-   * was deployed in this session). Useful after `wallet.deploy()`.
+   * Wait for the deploy transaction (only when deployed in this session).
+   * Accepts a timeout in ms (0.1.x) or WaitOptions, e.g. { until: 'final' }.
    */
-  async waitForDeploy(timeoutMs = 15e3) {
+  async waitForDeploy(timeoutOrOpts) {
     if (!this.deployTx) {
-      throw new Error("this contract was not deployed in this session \u2014 no deploy tx to wait for");
+      throw new AsentumError("INVALID_ARGUMENT", "this contract was not deployed in this session: there is no deploy tx to wait for");
     }
-    return this.deployTx.wait(timeoutMs);
+    return this.deployTx.wait(timeoutOrOpts);
   }
 };
 
-// src/wallet.ts
-function bytesToHex(bytes) {
-  let hex = "0x";
-  for (let i = 0; i < bytes.length; i++) {
-    hex += (bytes[i] ?? 0).toString(16).padStart(2, "0");
-  }
-  return hex;
-}
-function hexToBytes(hex) {
-  let h = hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
-  if (h.length % 2 !== 0) h = "0" + h;
-  const out = new Uint8Array(h.length / 2);
-  for (let i = 0; i < out.length; i++) {
-    out[i] = parseInt(h.slice(i * 2, i * 2 + 2), 16);
-  }
+// src/internal/tx.ts
+import { ByteListType, ByteVectorType, ContainerType, UintBigintType } from "@chainsafe/ssz";
+var MAX_TX_DATA_BYTES = 1048576;
+var Uint64 = new UintBigintType(8);
+var Uint256 = new UintBigintType(32);
+var AddressBytes = new ByteVectorType(ADDRESS_BYTES);
+var TransactionBodySchema = new ContainerType({
+  chainId: Uint64,
+  nonce: Uint64,
+  maxPriorityFeePerGas: Uint256,
+  maxFeePerGas: Uint256,
+  gasLimit: Uint64,
+  to: AddressBytes,
+  value: Uint256,
+  data: new ByteListType(MAX_TX_DATA_BYTES)
+});
+var LegacySignedTransactionSchema = new ContainerType({
+  body: TransactionBodySchema,
+  publicKey: new ByteVectorType(DILITHIUM3_PUBLIC_KEY_BYTES),
+  signature: new ByteVectorType(DILITHIUM3_SIGNATURE_BYTES)
+});
+var KeylessSignedTransactionSchema = new ContainerType({
+  body: TransactionBodySchema,
+  sender: AddressBytes,
+  signature: new ByteVectorType(DILITHIUM3_SIGNATURE_BYTES)
+});
+var KEYLESS_TX_SIGNING_DOMAIN = (() => {
+  const tag = new TextEncoder().encode("asentum/tx/keyless/v1");
+  const out = new Uint8Array(32);
+  out.set(tag, 0);
+  return out;
+})();
+function keylessSigningPreimage(body, sender) {
+  if (sender.length !== ADDRESS_BYTES) throw new Error(`key-less sender must be ${ADDRESS_BYTES} bytes`);
+  const bodyBytes = TransactionBodySchema.serialize(body);
+  const out = new Uint8Array(32 + ADDRESS_BYTES + bodyBytes.length);
+  out.set(KEYLESS_TX_SIGNING_DOMAIN, 0);
+  out.set(sender, 32);
+  out.set(bodyBytes, 32 + ADDRESS_BYTES);
   return out;
 }
-function hexToAddress20(hex) {
-  const bytes = hexToBytes(hex);
-  if (bytes.length !== 20) throw new Error(`expected 20-byte address, got ${bytes.length}`);
-  return bytes;
+function signLegacy(body, publicKey, secretKey) {
+  const digest = blake3(TransactionBodySchema.serialize(body));
+  const signature = sign(digest, secretKey);
+  const bytes = LegacySignedTransactionSchema.serialize({ body, publicKey, signature });
+  return { rawTx: bytesToHex(bytes), hash: bytesToHex(blake3(bytes)) };
+}
+function signKeyless(body, sender, secretKey) {
+  const digest = blake3(keylessSigningPreimage(body, sender));
+  const signature = sign(digest, secretKey);
+  const bytes = KeylessSignedTransactionSchema.serialize({ body, sender, signature });
+  return { rawTx: bytesToHex(bytes), hash: bytesToHex(blake3(bytes)) };
+}
+function contractAddressBytes(sender, nonce) {
+  const buf = new Uint8Array(ADDRESS_BYTES + 8);
+  buf.set(sender, 0);
+  new DataView(buf.buffer).setBigUint64(ADDRESS_BYTES, nonce, false);
+  return blake3(buf).slice(0, ADDRESS_BYTES);
+}
+
+// src/units.ts
+var WEI_PER_ASE = 1000000000000000000n;
+function numberToDecimalString(n) {
+  if (!Number.isFinite(n) || n < 0) throw new AsentumError("INVALID_ARGUMENT", `invalid amount: ${n}`);
+  return n.toLocaleString("en-US", { useGrouping: false, maximumFractionDigits: 20 });
+}
+function aseToWei(amount) {
+  const s = typeof amount === "number" ? numberToDecimalString(amount) : String(amount).trim();
+  const m = /^(\d+)(?:\.(\d*))?$/.exec(s);
+  if (!m) throw new AsentumError("INVALID_ARGUMENT", `invalid ASE amount: "${amount}" (use "1" or "1.5")`);
+  const whole = m[1];
+  const frac = (m[2] ?? "").replace(/0+$/, "");
+  if (frac.length > 18) throw new AsentumError("INVALID_ARGUMENT", `invalid ASE amount: "${amount}" has more than 18 decimals`);
+  return BigInt(whole) * WEI_PER_ASE + BigInt(frac.padEnd(18, "0") || "0");
 }
 function parseAse(amount) {
   if (typeof amount === "bigint") return amount;
-  if (typeof amount === "number") return BigInt(Math.floor(amount * 1e18));
+  if (typeof amount === "number") return aseToWei(amount);
   const s = amount.trim();
-  if (/^\d+$/.test(s)) {
-    if (s.length > 18) return BigInt(s);
-    return BigInt(s) * 1000000000000000000n;
-  }
-  if (/^\d+\.\d{1,18}$/.test(s)) {
-    const [whole, frac = ""] = s.split(".");
-    const padded = frac.padEnd(18, "0").slice(0, 18);
-    return BigInt(whole + padded);
-  }
-  throw new Error(`invalid amount: "${amount}" \u2014 use "1", "1.5", or a wei integer`);
+  if (/^\d+$/.test(s) && s.length > 18) return BigInt(s);
+  if (/^\d+(\.\d{1,18})?$/.test(s)) return aseToWei(s);
+  throw new AsentumError("INVALID_ARGUMENT", `invalid amount: "${amount}" (use "1", "1.5", or a bigint in wei)`);
 }
 function formatAse(wei) {
   const w = typeof wei === "bigint" ? wei : BigInt(wei);
-  const whole = w / 1000000000000000000n;
-  const frac = w % 1000000000000000000n;
-  if (frac === 0n) return whole.toString();
-  const fracStr = frac.toString().padStart(18, "0").replace(/0+$/, "");
-  return `${whole}.${fracStr}`;
+  const neg = w < 0n;
+  const abs = neg ? -w : w;
+  const whole = abs / WEI_PER_ASE;
+  const frac = abs % WEI_PER_ASE;
+  const out = frac === 0n ? whole.toString() : `${whole}.${frac.toString().padStart(18, "0").replace(/0+$/, "")}`;
+  return neg ? `-${out}` : out;
+}
+function toWei(v) {
+  if (typeof v === "bigint") return v;
+  if (typeof v === "number") {
+    if (!Number.isSafeInteger(v) || v < 0) throw new AsentumError("INVALID_ARGUMENT", `wei must be a non-negative integer, got ${v}`);
+    return BigInt(v);
+  }
+  if (!/^\d+$/.test(v.trim())) throw new AsentumError("INVALID_ARGUMENT", `wei must be a decimal integer string, got "${v}"`);
+  return BigInt(v.trim());
+}
+
+// src/wallet.ts
+function formatAddress(input) {
+  const bytes = typeof input === "string" ? addressToBytes(input) : input;
+  const wantHex = typeof process !== "undefined" && process?.env?.ASENTUM_ADDR_FORMAT === "hex";
+  return wantHex ? bytesToHex(bytes) : bytesToAse1(bytes);
+}
+function makeWait(client, hash) {
+  return (timeoutOrOpts) => client.waitForReceipt(hash, typeof timeoutOrOpts === "number" ? { timeoutMs: timeoutOrOpts } : timeoutOrOpts ?? {});
+}
+function pickWei(wei, loose) {
+  if (wei !== void 0) return toWei(wei);
+  if (loose !== void 0 && loose !== null && loose !== "") return parseAse(loose);
+  return 0n;
 }
 var AsentumWallet = class _AsentumWallet {
   client;
   keypair;
+  /**
+   * The wallet's address as ase1. (0.1.x returned checksummed 0x hex here;
+   * use `addressHex` for the hex form.)
+   */
   address;
-  constructor(client, keypair) {
+  /** The same address as lowercase 0x hex: what contracts see as msg.sender. */
+  addressHex;
+  /** Key-less mode for transactions from this wallet. */
+  keyless;
+  addressBytes;
+  nextNonce;
+  queue = Promise.resolve();
+  keyOnRecord = false;
+  keyCheckedAt = 0;
+  constructor(client, keypair, opts = {}) {
     this.client = client;
     this.keypair = keypair;
-    this.address = addressFromPublicKey(keypair.publicKey);
-  }
-  /** Create a wallet with a random Dilithium3 keypair. */
-  static create(client) {
-    const seed = new Uint8Array(32);
-    crypto.getRandomValues(seed);
-    const keypair = generateKeypair(seed);
-    return new _AsentumWallet(client, keypair);
-  }
-  /** Create a wallet from a 32-byte seed. */
-  static fromSeed(client, seed) {
-    if (seed.length < 32) throw new Error("seed must be at least 32 bytes");
-    const keypair = generateKeypair(seed.slice(0, 32));
-    return new _AsentumWallet(client, keypair);
-  }
-  /** Create a wallet from a hex-encoded secret key. */
-  static fromSecretKey(client, secretKeyHex, publicKeyHex) {
-    return new _AsentumWallet(client, {
-      secretKey: hexToBytes(secretKeyHex),
-      publicKey: hexToBytes(publicKeyHex)
-    });
+    this.addressBytes = addressBytesFromPublicKey(keypair.publicKey);
+    this.address = bytesToAse1(this.addressBytes);
+    this.addressHex = bytesToHex(this.addressBytes);
+    this.keyless = opts.keyless ?? "off";
+  }
+  /** A wallet with a random keypair. */
+  static create(client, opts) {
+    return new _AsentumWallet(client, generateKeypair(), opts);
+  }
+  /** A wallet from a seed (the first 32 bytes are used). Same seed, same keys. */
+  static fromSeed(client, seed, opts) {
+    if (seed.length < 32) throw new AsentumError("INVALID_ARGUMENT", "seed must be at least 32 bytes");
+    return new _AsentumWallet(client, generateKeypair(seed.slice(0, 32)), opts);
   }
-  /** Get the secret key as a hex string (for export/backup). */
+  /** A wallet from exported hex keys (secretKeyHex / publicKeyHex). */
+  static fromSecretKey(client, secretKeyHex, publicKeyHex, opts) {
+    return new _AsentumWallet(client, { secretKey: hexToBytes(secretKeyHex), publicKey: hexToBytes(publicKeyHex) }, opts);
+  }
+  /** The secret key as hex, for backup. Treat it like a password. */
   get secretKeyHex() {
     return bytesToHex(this.keypair.secretKey);
   }
-  /** Get the public key as a hex string. */
+  /** The public key as hex. */
   get publicKeyHex() {
     return bytesToHex(this.keypair.publicKey);
   }
-  /** Get the current balance in wei. */
+  /** Balance in wei. */
   async getBalance() {
-    const bal = await this.client.getBalance(this.address);
-    return BigInt(bal.balance);
+    return BigInt((await this.client.getBalance(this.address)).balance);
   }
-  /** Get the current nonce. */
+  /** The node's pendingNonce for this wallet (the nonce the next transaction would use, ignoring local allocations). */
   async getNonce() {
     return this.client.getNonce(this.address);
   }
-  /** Request test ASE from the faucet. */
+  /**
+   * Forget locally allocated nonces; the next transaction asks the node
+   * again. The wallet does this itself after a rejection.
+   */
+  resetNonce() {
+    this.nextNonce = void 0;
+  }
+  /**
+   * @deprecated POST /dev/faucet is off on every public node (see
+   * AsentumClient.faucet). Use the airdrop dashboard for test ASE.
+   */
   async requestFaucet(amount = "100000000000000000000") {
     return this.client.faucet(this.address, amount);
   }
   // ---------------------------------------------------------------------------
-  // Sending transactions
+  // Send (sign + submit)
   // ---------------------------------------------------------------------------
-  /** Send ASE to another address. */
+  /** Send ASE. Throws TxRejectedError when the node does not accept it. */
   async sendTransfer(opts) {
-    const chainId = await this.client.getChainId();
-    const nonce = opts.nonce ?? await this.getNonce();
-    const value = parseAse(opts.amount);
-    const body = {
-      chainId,
-      nonce,
-      maxPriorityFeePerGas: 0n,
-      maxFeePerGas: 1n,
-      gasLimit: opts.gasLimit ?? 21000n,
-      to: hexToAddress20(opts.to),
-      value,
-      data: new Uint8Array(0)
-    };
-    return this.signAndSubmit(body);
+    return this.serial(async () => this.submit(await this.buildTransfer(opts), opts.signal));
   }
-  /** Call a method on a deployed contract (state-changing). */
+  /** Call a contract method (state-changing). Throws TxRejectedError when the node does not accept it. */
   async sendCall(opts) {
-    const chainId = await this.client.getChainId();
-    const nonce = opts.nonce ?? await this.getNonce();
-    const data = new TextEncoder().encode(
-      JSON.stringify({ method: opts.method, args: opts.args ?? [] })
-    );
-    const body = {
-      chainId,
-      nonce,
-      maxPriorityFeePerGas: 0n,
-      maxFeePerGas: 1n,
-      gasLimit: opts.gasLimit ?? 2000000n,
-      to: hexToAddress20(opts.to),
-      value: opts.value ? parseAse(opts.value) : 0n,
-      data
-    };
-    return this.signAndSubmit(body);
+    return this.serial(async () => this.submit(await this.buildCall(opts), opts.signal));
+  }
+  /**
+   * Same as sendCall, but `value` is in wei. Use this when you hold wei
+   * amounts (balances, contract return values) so nothing is reinterpreted.
+   */
+  async sendCallWei(opts) {
+    const { value, ...rest } = opts;
+    return this.sendCall({ ...rest, valueWei: value ?? 0n });
   }
-  /** Deploy a new smart contract. Returns an AsentumContract instance. */
+  /** Same as sendTransfer, but `amount` is in wei. */
+  async sendTransferWei(opts) {
+    const { amount, ...rest } = opts;
+    return this.sendTransfer({ ...rest, amountWei: amount });
+  }
+  /**
+   * Deploy a contract. Returns an AsentumContract at the derived address
+   * right away; the deploy is only accepted, so `await contract.waitForDeploy()`
+   * before using it.
+   */
   async deploy(sourceOrOpts) {
     const opts = typeof sourceOrOpts === "string" ? { source: sourceOrOpts } : sourceOrOpts;
+    const sent = await this.serial(async () => this.submit(await this.buildDeploy(opts), opts.signal));
+    return new AsentumContract(this.client, sent.contractAddress, sent, this);
+  }
+  // ---------------------------------------------------------------------------
+  // Sign only, and batches
+  // ---------------------------------------------------------------------------
+  /** Sign a transfer without submitting it (allocates the next nonce unless given). */
+  async signTransfer(opts) {
+    return this.serial(() => this.buildTransfer(opts));
+  }
+  /** Sign a contract call without submitting it. */
+  async signCall(opts) {
+    return this.serial(() => this.buildCall(opts));
+  }
+  /** Sign a deploy without submitting it. `contractAddress` is the address it will get. */
+  async signDeploy(opts) {
+    return this.serial(() => this.buildDeploy(opts));
+  }
+  /**
+   * Submit several signed transactions in one request (POST /tx/batch), in
+   * the given order. Sign them first with signTransfer / signCall /
+   * signDeploy (consecutive calls get consecutive nonces). One rejection
+   * does not stop the rest, but a nonce gap leaves later ones waiting.
+   * Does not throw on rejections: check each result.
+   */
+  async sendBatch(txs, opts = {}) {
+    const r = await this.client.submitRawTxBatch(txs.map((t) => t.rawTx), { signal: opts.signal });
+    if (r.rejected > 0) this.resetNonce();
+    return {
+      accepted: r.accepted,
+      rejected: r.rejected,
+      total: r.total,
+      results: txs.map((t, i) => {
+        const res = r.results[i] ?? { accepted: false, reason: "no result from node" };
+        const hash = res.txHash ?? t.hash;
+        return { ...res, hash, nonce: t.nonce, wait: makeWait(this.client, hash) };
+      })
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  /** Run fn after every earlier send/sign of this wallet, so nonces are handed out in order. */
+  serial(fn) {
+    const run = this.queue.then(fn, fn);
+    this.queue = run.catch(() => void 0);
+    return run;
+  }
+  async allocateNonce(explicit) {
+    if (explicit !== void 0) return explicit;
+    const fromNode = await this.client.getNonce(this.address);
+    const n = this.nextNonce !== void 0 && this.nextNonce > fromNode ? this.nextNonce : fromNode;
+    this.nextNonce = n + 1n;
+    return n;
+  }
+  async useKeyless(mode) {
+    const m = mode ?? this.keyless;
+    if (m === "off") return false;
+    if (m === "always") return true;
+    if (this.keyOnRecord) return true;
+    if (Date.now() - this.keyCheckedAt < 6e4) return false;
+    this.keyCheckedAt = Date.now();
+    try {
+      this.keyOnRecord = (await this.client.getPublicKeyStatus(this.address)).canOmitKey === true;
+    } catch {
+      this.keyOnRecord = false;
+    }
+    return this.keyOnRecord;
+  }
+  async build(fields, common, isDeploy = false) {
     const chainId = await this.client.getChainId();
-    const nonce = opts.nonce ?? await this.getNonce();
-    const data = new TextEncoder().encode(opts.source);
-    const gasLimit = opts.gasLimit ?? BigInt(Math.max(2e6, 1e3 * opts.source.length));
+    const keyless = await this.useKeyless(common.keyless);
+    const nonce = await this.allocateNonce(common.nonce);
     const body = {
       chainId,
       nonce,
       maxPriorityFeePerGas: 0n,
-      maxFeePerGas: 1n,
-      gasLimit,
-      to: new Uint8Array(20),
-      // zero address = deploy
-      value: opts.value ? parseAse(opts.value) : 0n,
-      data
+      maxFeePerGas: common.maxFeePerGas ?? 1n,
+      gasLimit: common.gasLimit ?? fields.gasLimit,
+      to: fields.to,
+      value: fields.value,
+      data: fields.data
     };
-    const sentTx = await this.signAndSubmit(body);
-    const senderBytes = hexToAddress20(this.address);
-    const nonceBytes = new Uint8Array(8);
-    new DataView(nonceBytes.buffer).setBigUint64(0, nonce, true);
-    const combined = new Uint8Array(20 + 8);
-    combined.set(senderBytes);
-    combined.set(nonceBytes, 20);
-    const hash = blake3(combined);
-    const contractAddress = bytesToHex(hash.slice(0, 20));
-    return new AsentumContract(this.client, contractAddress, sentTx, this);
-  }
-  // ---------------------------------------------------------------------------
-  // Internal: sign + submit
-  // ---------------------------------------------------------------------------
-  async signAndSubmit(body) {
-    const bodyBytes = TransactionBodySchema.serialize(body);
-    const digest = blake3(bodyBytes);
-    const signature = sign(digest, this.keypair.secretKey);
-    const signedTx = {
-      body,
-      publicKey: this.keypair.publicKey,
-      signature
+    const signed = keyless ? signKeyless(body, this.addressBytes, this.keypair.secretKey) : signLegacy(body, this.keypair.publicKey, this.keypair.secretKey);
+    return {
+      ...signed,
+      nonce,
+      from: this.address,
+      ...isDeploy ? { contractAddress: bytesToAse1(contractAddressBytes(this.addressBytes, nonce)) } : {}
     };
-    const rawTxHex = bytesToHex(SignedTransactionSchema.serialize(signedTx));
-    const result = await this.client.submitRawTx(rawTxHex);
-    if (!result.accepted) {
-      throw new Error(`transaction rejected: ${result.reason || "unknown reason"}`);
+  }
+  buildTransfer(opts) {
+    if (opts.amountWei === void 0 && opts.amount === void 0) {
+      throw new AsentumError("INVALID_ARGUMENT", "sendTransfer needs amount or amountWei");
     }
-    const txHash = result.txHash ?? "(unknown)";
-    const client = this.client;
+    return this.build(
+      { to: addressToBytes(opts.to), value: pickWei(opts.amountWei, opts.amount), data: new Uint8Array(0), gasLimit: 21000n },
+      opts
+    );
+  }
+  buildCall(opts) {
+    const data = new TextEncoder().encode(JSON.stringify({ method: opts.method, args: ase1ArgsToHex(opts.args ?? []) }));
+    return this.build(
+      { to: addressToBytes(opts.to), value: pickWei(opts.valueWei, opts.value), data, gasLimit: 2000000n },
+      opts
+    );
+  }
+  buildDeploy(opts) {
+    const data = new TextEncoder().encode(opts.source);
+    return this.build(
+      {
+        to: new Uint8Array(20),
+        // zero address = deploy
+        value: pickWei(opts.valueWei, opts.value),
+        data,
+        gasLimit: BigInt(Math.max(2e6, 1e3 * opts.source.length))
+      },
+      opts,
+      true
+    );
+  }
+  async submit(signed, signal) {
+    let result;
+    try {
+      result = await this.client.submitRawTx(signed.rawTx, { signal });
+    } catch (err) {
+      this.resetNonce();
+      throw err;
+    }
+    if (!result || !result.accepted) {
+      this.resetNonce();
+      throw new TxRejectedError(result?.reason ?? "unknown reason", signed.hash);
+    }
+    const hash = result.txHash ?? signed.hash;
     return {
-      hash: txHash,
-      async wait(timeoutMs = 15e3) {
-        const start = Date.now();
-        while (Date.now() - start < timeoutMs) {
-          const receipt = await client.getReceipt(txHash);
-          if (receipt) return receipt;
-          await new Promise((r) => setTimeout(r, 1e3));
-        }
-        throw new Error(`transaction ${txHash} not confirmed within ${timeoutMs}ms`);
-      }
+      hash,
+      nonce: signed.nonce,
+      from: signed.from,
+      ...signed.contractAddress ? { contractAddress: signed.contractAddress } : {},
+      wait: makeWait(this.client, hash)
     };
   }
 };
+function getContractAddress(sender, nonce) {
+  return bytesToAse1(contractAddressBytes(addressToBytes(sender), BigInt(nonce)));
+}
+
+// src/index.ts
+var VERSION = "0.2.0";
 export {
+  AbortError,
   AsentumClient,
   AsentumContract,
+  AsentumError,
   AsentumWallet,
+  DEFAULT_RPC,
+  GOVERNANCE_CONTRACT,
+  HttpError,
+  JsonRpcError,
+  MAX_LOG_RANGE,
+  NetworkError,
+  RateLimitError,
+  RpcError,
+  TimeoutError,
+  TxFailedError,
+  TxRejectedError,
+  VERSION,
+  ViewError,
+  addressToBytes,
+  ase1ArgsToHex,
+  ase1ToHex,
+  ase1ToHexOrNull,
+  aseToWei,
+  bytesToAse1,
+  eventTopic,
+  formatAddress,
   formatAse,
-  parseAse
+  getContractAddress,
+  hexToAse1,
+  isAddress,
+  isAse1,
+  isHexAddress,
+  parseAse,
+  shortAse1,
+  toAse1,
+  toHexAddress,
+  toWei
 };
 //# sourceMappingURL=index.js.map