@leofcoin/chain 1.10.22 → 1.11.0

package/exports/browser/chain.js

@@ -1,11 +1,20 @@
-import { F as FormatInterface, p as proto, a as proto$1, b as proto$2, T as TransactionMessage, j as jsonStringifyBigInt, c as jsonParseBigInt, C as ContractMessage, d as Codec } from './browser-crypto-CH0ua22L.js';
-import { P as Protocol, B as BlockMessage, L as LastBlockMessage, a as PROTOCOL_VERSION, R as REACHED_ONE_ZERO_ZERO, C as ConnectionMonitor, b as BWMessage, S as StateMessage } from './connection-monitor-DMGAhcC0.js';
-import { M as MAX_TRANSACTION_BYTES, a as MAX_BLOCK_TRANSACTION_BYTES, b as MAX_BLOCK_TRANSACTIONS, c as MultiWallet, d as createTransactionHash, e as calculateFee, f as createContractMessage, s as signTransaction, r as randombytes, g as distributeTransactionFee, h as supportsTransactionFees, i as supportsMonetaryPolicy, v as validateBlockResourceLimits, j as calculateMonetaryPolicy, k as distributeAmount, l as aggregateValidatorFees, m as MONETARY_POLICY_AUTHORITY, n as contractFactoryMessage, o as nativeTokenMessage, p as validatorsMessage, q as nameServiceMessage, t as parseUnits, u as formatUnits } from './index-dxD17Fom.js';
+import { C as Codec, B as BinaryFormat, p as proto, a as proto$1, b as proto$2, T as TransactionMessage, j as jsonParseBigInt, c as jsonStringifyBigInt, d as ContractMessage, e as decodeWire$1, f as encodeWire$1 } from './browser-crypto-B_UJguhk.js';
+import { P as Protocol, B as BlockMessage, L as LastBlockMessage, a as PROTOCOL_VERSION, R as REACHED_ONE_ZERO_ZERO, C as ConnectionMonitor, b as BWMessage, S as StateMessage } from './connection-monitor-BzbeYGEt.js';
 import { f as fromBase58 } from './index-CvKt4UDE.js';
+import { M as MAX_TRANSACTION_BYTES, a as MAX_BLOCK_TRANSACTION_BYTES, b as MAX_BLOCK_TRANSACTIONS, c as MultiWallet, d as createTransactionHash, e as calculateFee, f as createContractMessage, s as signTransaction, r as randombytes, g as supportsTransactionFees, h as supportsMonetaryPolicy, v as validateBlockResourceLimits, i as aggregateValidatorFees, j as distributeAmount, k as MONETARY_POLICY_AUTHORITY, l as calculateMonetaryPolicy, m as contractFactoryMessage, n as nativeTokenMessage, o as validatorsMessage, p as nameServiceMessage, q as parseUnits, t as formatUnits, u as distributeTransactionFee } from './index-phv5KvaE.js';
 import { g as getDefaultExportFromCjs } from './_commonjsHelpers-B85MJLTf.js';
 import { q as quorumThreshold } from './quorum-S_qdgiAY.js';
 import './sha2-BKcEJzgd.js';
 
+const decodeResponsePayload = async (result) => {
+  if (!(result instanceof Uint8Array)) throw new TypeError("Peer response must be Uint8Array");
+  const codec = new Codec(result);
+  if (codec.name !== "peernet-response") return result;
+  const ResponseMessage = globalThis.peernet?.protos?.["peernet-response"];
+  if (!ResponseMessage) throw new Error("peernet-response codec is not registered");
+  return new ResponseMessage(result).decoded.response;
+};
+
 const getTargets = () => Array.from([]);
 const isEnabled = (target) => {
     return false;
@@ -42,7 +51,7 @@ const formatBytes = (bytes, decimals = 2) => {
   return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${byteFormats[i]}`;
 };
 
-class PrevoteMessage extends FormatInterface {
+class PrevoteMessage extends BinaryFormat {
   get messageName() {
     return "PrevoteMessage";
   }
@@ -54,7 +63,7 @@ class PrevoteMessage extends FormatInterface {
   }
 }
 
-class PrecommitMessage extends FormatInterface {
+class PrecommitMessage extends BinaryFormat {
   get messageName() {
     return "PrecommitMessage";
   }
@@ -66,7 +75,7 @@ class PrecommitMessage extends FormatInterface {
   }
 }
 
-class ProposalMessage extends FormatInterface {
+class ProposalMessage extends BinaryFormat {
   get messageName() {
     return "ProposalMessage";
   }
@@ -78,10 +87,10 @@ class ProposalMessage extends FormatInterface {
   }
 }
 
-var contractFactory$1 = "B3OGRUBSBGSASFXWDZUI6AYITY76PYQZS4O5UDWVLSW56X5CSWTQGTGQHUGU";
-var nativeToken$1 = "B3OGRUBSA5V74HIRRP6YPMZYDZ7YM3SR3MQX63XSYEZIZ7TWHBPDWRWVA2XA";
-var nameService$1 = "B3OGRUBSBXX7EPFWHGZQGGSWBMMK7ATOSDICOW5CCFP25OMZBTRMHYGM4KFF";
-var validators$1 = "B3OGRUBSBXLCYRTXG5SRL6XNINEJNAI7CLJBKSRCXY24GMFU5ZY7TXHAGJGT";
+var contractFactory$1 = "B3OGRUBSARKAMWHZLZZAL5Y4SRUJOE4RIMQX4SELNLMTQVPBGFQXEF5RPPHV";
+var nativeToken$1 = "B3OGRUBSBSWHYGNYT4O57EK7Q5ZNXYFR23CCS4EUQPQ34RU57V6ROQNLYIVN";
+var nameService$1 = "B3OGRUBSB23VEDKVPQM5DYREJVI2XYMSQ44ZN3NQG445AZMASFMOUU4P7HLM";
+var validators$1 = "B3OGRUBSBT6UD4G6V3KP7Z6G2DLMMOV5D5IFIZH2I3KD2CK6VFD3CYY2NCKV";
 var addresses$1 = {
   contractFactory: contractFactory$1,
   nativeToken: nativeToken$1,
@@ -2915,26 +2924,46 @@ function requireSemver () {
 var semverExports = requireSemver();
 var semver = /*@__PURE__*/getDefaultExportFromCjs(semverExports);
 
-const waitForCanonicalTransaction = (pubsub, transactionPool, hash) => new Promise((resolve, reject) => {
-  const completionTopic = `transaction.completed.${hash}`;
-  const cleanup = () => {
-    pubsub.unsubscribe("block-processed", blockProcessed);
-    pubsub.unsubscribe(completionTopic, transactionCompleted);
+const createCanonicalTransactionWaiter = (pubsub, transactionPool, hash) => {
+  let cleanup = () => {
   };
-  const blockProcessed = (block) => {
-    if (!Array.isArray(block?.transactions) || !block.transactions.includes(hash)) return;
-    cleanup();
-    resolve(hash);
+  let cancel = (_reason) => {
   };
-  const transactionCompleted = async (result) => {
-    if (result?.status === "fulfilled") return;
-    await transactionPool.delete(hash);
-    cleanup();
-    reject({ hash, error: result?.error });
-  };
-  pubsub.subscribe("block-processed", blockProcessed);
-  pubsub.subscribe(completionTopic, transactionCompleted);
-});
+  const wait = new Promise((resolve, reject) => {
+    const completionTopic = `transaction.completed.${hash}`;
+    let settled = false;
+    cancel = (reason) => {
+      if (settled) return;
+      settled = true;
+      reject({ hash, error: reason });
+    };
+    cleanup = () => {
+      pubsub.unsubscribe("block-processed", blockProcessed);
+      pubsub.unsubscribe(completionTopic, transactionCompleted);
+    };
+    const blockProcessed = (block) => {
+      if (settled || !Array.isArray(block?.transactions) || !block.transactions.includes(hash)) return;
+      settled = true;
+      resolve(hash);
+    };
+    const transactionCompleted = async (result) => {
+      if (settled || result?.status === "fulfilled") return;
+      settled = true;
+      try {
+        await transactionPool.delete(hash);
+        reject({ hash, error: result?.error });
+      } catch (error) {
+        reject({ hash, error, transactionError: result?.error });
+      }
+    };
+    pubsub.subscribe("block-processed", blockProcessed);
+    pubsub.subscribe(completionTopic, transactionCompleted);
+  });
+  const finalized = wait.finally(() => cleanup());
+  void finalized.catch(() => {
+  });
+  return { wait: finalized, cancel };
+};
 
 class Transaction extends Protocol {
   #pendingNonces = /* @__PURE__ */ new Map();
@@ -3135,9 +3164,10 @@ class Transaction extends Protocol {
     await this.validateTransactionSignature(message);
     await this.validateNonce(message.decoded.from, message.decoded.nonce);
     const hash = await message.hash();
+    const fee = await calculateFee(message.decoded);
+    const waiter = createCanonicalTransactionWaiter(pubsub, transactionPoolStore, hash);
     try {
       let data;
-      const wait = waitForCanonicalTransaction(pubsub, transactionPoolStore, hash);
       await globalThis.transactionPoolStore.put(hash, message.encoded);
       this.addPendingNonce(message.decoded.from, message.decoded.nonce);
       try {
@@ -3145,12 +3175,16 @@ class Transaction extends Protocol {
       } catch (publishError) {
         console.warn("peernet publish failed: add-transaction", publishError?.message ?? publishError);
       }
-      const fee = await calculateFee(message.decoded);
-      return { hash, data, fee, wait, message };
+      return { hash, data, fee, wait: waiter.wait, message };
     } catch (error) {
-      console.log("remo");
-      await transactionPoolStore.delete(hash);
-      this.removePendingNonce(message.decoded.from, message.decoded.nonce);
+      waiter.cancel(error);
+      try {
+        await transactionPoolStore.delete(hash);
+      } catch (cleanupError) {
+        console.warn("failed to clean up rejected transaction:", cleanupError);
+      } finally {
+        this.removePendingNonce(message.decoded.from, message.decoded.nonce);
+      }
       throw error;
     }
   }
@@ -3478,120 +3512,541 @@ class Contract extends Transaction {
 }
 
 class EasyWorker {
-    #messageEvent = 'message';
-    #errorEvent = 'error';
-    #isBrowser = false;
-    #isWorker = false;
-    #messageHandler = null;
-    #errorHandler = null;
-    worker;
-    get isWorker() {
-        return this.#isWorker;
-    }
-    constructor(url, options) {
-        return this.#init(url, options);
-    }
-    #init(url, options = {}) {
-        if (url) {
-            if (globalThis.Worker) {
-                this.#isBrowser = true;
-                this.worker = new Worker(url, { ...options });
-            }
-            else {
-                return new Promise((resolve, reject) => {
-                    import('child_process').then(({ fork }) => {
-                        const child = fork(url, ['easy-worker-child'], options);
-                        child.once('error', reject);
-                        this.worker = child;
-                        resolve(this);
-                    }).catch(reject);
-                });
-            }
-        }
-        else {
-            this.#isWorker = true;
-            if (globalThis.process?.argv[2] === 'easy-worker-child') {
-                this.worker = process;
-            }
-            else {
-                this.#isBrowser = true;
-                this.worker = globalThis;
-            }
-        }
-        return this;
+  #messageEvent = "message";
+  #errorEvent = "error";
+  #isBrowser = false;
+  #isWorker = false;
+  #messageHandler = null;
+  #errorHandler = null;
+  worker;
+  get isWorker() {
+    return this.#isWorker;
+  }
+  constructor(url, options) {
+    return this.#init(url, options);
+  }
+  #init(url, options = {}) {
+    if (url) {
+      if (globalThis.Worker) {
+        this.#isBrowser = true;
+        this.worker = new Worker(url, { ...options });
+      } else {
+        return new Promise((resolve, reject) => {
+          import('child_process').then(({ fork }) => {
+            const child = fork(url, ["easy-worker-child"], options);
+            child.once("error", reject);
+            this.worker = child;
+            resolve(this);
+          }).catch(reject);
+        });
+      }
+    } else {
+      this.#isWorker = true;
+      if (globalThis.process?.argv[2] === "easy-worker-child") {
+        this.worker = process;
+      } else {
+        this.#isBrowser = true;
+        this.worker = globalThis;
+      }
     }
-    onmessage(fn) {
-        if (this.#isBrowser) {
-            this.worker.onmessage = ({ data }) => fn(data);
-        }
-        else {
-            if (this.#messageHandler)
-                this.worker.off(this.#messageEvent, this.#messageHandler);
-            this.#messageHandler = fn;
-            this.worker.on(this.#messageEvent, fn);
-        }
+    return this;
+  }
+  onmessage(fn) {
+    if (this.#isBrowser) {
+      this.worker.onmessage = ({ data }) => fn(data);
+    } else {
+      if (this.#messageHandler)
+        this.worker.off(this.#messageEvent, this.#messageHandler);
+      this.#messageHandler = fn;
+      this.worker.on(this.#messageEvent, fn);
     }
-    postMessage(message) {
-        if (this.#isBrowser)
-            this.worker.postMessage(message);
-        else
-            this.worker.send(message);
+  }
+  postMessage(message) {
+    if (this.#isBrowser)
+      this.worker.postMessage(message);
+    else
+      this.worker.send(message);
+  }
+  terminate() {
+    if (this.#isBrowser)
+      this.worker.terminate();
+    else
+      this.worker.kill();
+  }
+  onerror(fn) {
+    if (this.#isBrowser) {
+      this.worker.onerror = fn;
+    } else {
+      if (this.#errorHandler)
+        this.worker.off(this.#errorEvent, this.#errorHandler);
+      this.#errorHandler = fn;
+      this.worker.on(this.#errorEvent, fn);
     }
-    terminate() {
-        if (this.#isBrowser)
-            this.worker.terminate();
-        else
-            this.worker.kill();
+  }
+  /**
+   *
+   * @param {*} data
+   * @returns {Promise} resolves result onmessage & rejects on error
+   */
+  once(data) {
+    return new Promise((resolve, reject) => {
+      if (this.#isBrowser) {
+        const handleMessage = ({ data: result }) => {
+          this.worker.onerror = null;
+          resolve(result);
+          this.terminate();
+        };
+        const handleError = (error) => {
+          this.worker.onmessage = null;
+          reject(error);
+          this.terminate();
+        };
+        this.worker.onmessage = handleMessage;
+        this.worker.onerror = handleError;
+      } else {
+        const handleMessage = (result) => {
+          this.worker.off(this.#errorEvent, handleError);
+          resolve(result);
+          this.terminate();
+        };
+        const handleError = (error) => {
+          this.worker.off(this.#messageEvent, handleMessage);
+          reject(error);
+          this.terminate();
+        };
+        this.worker.once(this.#messageEvent, handleMessage);
+        this.worker.once(this.#errorEvent, handleError);
+      }
+      this.postMessage(data);
+    });
+  }
+}
+const MAX_BIGINT = (1n << 256n) - 1n;
+function size(value) {
+  if (!Number.isSafeInteger(value) || value < 0)
+    throw new RangeError("Expected an unsigned safe integer");
+}
+function bytes(value) {
+  if (!(value instanceof Uint8Array))
+    throw new TypeError("Expected Uint8Array");
+}
+function varUintLength(value) {
+  size(value);
+  let length = 1;
+  while (value >= 128) {
+    value = Math.floor(value / 128);
+    length++;
+  }
+  return length;
+}
+function varBigIntLength(value) {
+  if (typeof value !== "bigint")
+    throw new TypeError("Expected BigInt");
+  if (value < 0n || value > MAX_BIGINT)
+    throw new RangeError("Expected an unsigned 256-bit integer");
+  let length = 1;
+  while (value >= 0x100000000000000n) {
+    value >>= 56n;
+    length += 8;
+  }
+  while (value >= 128n) {
+    value >>= 7n;
+    length++;
+  }
+  return length;
+}
+class BinaryReader {
+  #buffer;
+  #position = 0;
+  constructor(buffer) {
+    bytes(buffer);
+    this.#buffer = buffer;
+  }
+  get position() {
+    return this.#position;
+  }
+  get remaining() {
+    return this.#buffer.length - this.#position;
+  }
+  readVarUint(canonical = true) {
+    let result = 0;
+    let multiplier = 1;
+    for (let index = 0; index < 8; index++) {
+      const cursor = this.#position + index;
+      if (cursor >= this.#buffer.length)
+        throw new RangeError("Truncated varint");
+      const byte = this.#buffer[cursor];
+      const payload = byte & 127;
+      if (index === 7 && payload > Math.floor((Number.MAX_SAFE_INTEGER - result) / multiplier))
+        throw new RangeError("Varint exceeds safe integer range");
+      result += payload * multiplier;
+      if (byte < 128) {
+        if (canonical && index > 0 && payload === 0)
+          throw new RangeError("Non-canonical varint");
+        this.#position = cursor + 1;
+        return result;
+      }
+      multiplier *= 128;
+    }
+    throw new RangeError("Varint exceeds safe integer range");
+  }
+  readVarBigInt(canonical = true) {
+    let result = 0n;
+    for (let index = 0; index < 37; index++) {
+      const cursor = this.#position + index;
+      if (cursor >= this.#buffer.length)
+        throw new RangeError("Truncated varint");
+      const byte = this.#buffer[cursor];
+      result |= BigInt(byte & 127) << BigInt(index * 7);
+      if (result > MAX_BIGINT)
+        throw new RangeError("Varint exceeds 256 bits");
+      if (byte < 128) {
+        if (canonical && index > 0 && byte === 0)
+          throw new RangeError("Non-canonical varint");
+        this.#position = cursor + 1;
+        return result;
+      }
+    }
+    throw new RangeError("Varint exceeds 256 bits");
+  }
+  readBytes(length) {
+    size(length);
+    if (length > this.remaining)
+      throw new RangeError("Truncated binary field");
+    const start = this.#position;
+    this.#position += length;
+    return this.#buffer.subarray(start, this.#position);
+  }
+  readFrame(canonical = true) {
+    const start = this.#position;
+    try {
+      return this.readBytes(this.readVarUint(canonical));
+    } catch (error) {
+      this.#position = start;
+      throw error;
     }
-    onerror(fn) {
-        if (this.#isBrowser) {
-            this.worker.onerror = fn;
+  }
+}
+const MAGIC = new Uint8Array([76, 70, 67, 1]);
+const utf8 = new TextEncoder();
+const text$1 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+const defaults = { maxBytes: 16 * 1024 * 1024, maxDepth: 64, maxNodes: 2e5 };
+const BIGINT_LIMB = 1n << 49n;
+const BIGINT_MASK = BIGINT_LIMB - 1n;
+const limitsFor = (options) => {
+  const limits = { ...defaults, ...options };
+  for (const value of Object.values(limits))
+    if (!Number.isSafeInteger(value) || value < 1)
+      throw new RangeError("Invalid binary limits");
+  return limits;
+};
+function stringLength(value, maximum) {
+  if (value.length > maximum)
+    throw new RangeError("Invalid binary string");
+  let length = value.length;
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code < 128)
+      continue;
+    if (code < 2048) {
+      length++;
+      continue;
+    }
+    if (code >= 55296 && code <= 56319) {
+      const low = value.charCodeAt(++index);
+      if (!(low >= 56320 && low <= 57343))
+        throw new RangeError("Invalid binary string");
+      length += 2;
+    } else {
+      if (code >= 56320 && code <= 57343)
+        throw new RangeError("Invalid binary string");
+      length += 2;
+    }
+  }
+  return length;
+}
+function encodeValue(value, options = {}) {
+  return encodeValueWithPrefix(value, EMPTY, options);
+}
+const EMPTY = new Uint8Array();
+function encodeValueWithPrefix(value, prefix, options = {}) {
+  if (!(prefix instanceof Uint8Array))
+    throw new TypeError("Expected Uint8Array prefix");
+  const limits = limitsFor(options);
+  const plan = [];
+  const ancestors = /* @__PURE__ */ new Set();
+  let size2 = MAGIC.length;
+  let nodes = 0;
+  const reserve = (length) => {
+    size2 += length;
+    if (size2 > limits.maxBytes)
+      throw new RangeError("Binary value exceeds byte limit");
+  };
+  const string = (value2, tag) => {
+    const length = stringLength(value2, limits.maxBytes);
+    reserve((tag === 7 ? 1 : 0) + varUintLength(length) + length);
+    plan.push(tag, value2, length);
+  };
+  const visit = (value2, depth) => {
+    if (++nodes > limits.maxNodes || depth > limits.maxDepth)
+      throw new RangeError("Binary value exceeds complexity limit");
+    if (value2 === void 0 || value2 === null || typeof value2 === "boolean") {
+      reserve(1);
+      plan.push(value2 === void 0 ? 0 : value2 === null ? 1 : value2 === false ? 2 : 3);
+      return;
+    }
+    if (typeof value2 === "number") {
+      if (!Number.isFinite(value2))
+        throw new TypeError("Binary numbers must be finite");
+      reserve(9);
+      plan.push(4, value2);
+      return;
+    }
+    if (typeof value2 === "bigint") {
+      const magnitude = value2 < 0n ? -value2 : value2;
+      reserve(1 + varBigIntLength(magnitude));
+      plan.push(value2 < 0n ? 6 : 5, magnitude);
+      return;
+    }
+    if (typeof value2 === "string")
+      return string(value2, 7);
+    if (value2 instanceof Uint8Array) {
+      reserve(1 + varUintLength(value2.length) + value2.length);
+      plan.push(8, value2, value2.length);
+      return;
+    }
+    if (typeof value2 !== "object")
+      throw new TypeError("Unsupported binary value");
+    if (ancestors.has(value2))
+      throw new TypeError("Cyclic binary value");
+    ancestors.add(value2);
+    try {
+      if (Array.isArray(value2)) {
+        if (value2.length > limits.maxNodes - nodes)
+          throw new RangeError("Binary array exceeds node limit");
+        if (Object.keys(value2).length !== value2.length || Object.getOwnPropertySymbols(value2).length)
+          throw new TypeError("Binary arrays cannot have extra properties or holes");
+        reserve(1 + varUintLength(value2.length));
+        plan.push(9, value2.length);
+        for (let index = 0; index < value2.length; index++) {
+          const entry = Object.getOwnPropertyDescriptor(value2, String(index));
+          if (!entry || !("value" in entry))
+            throw new TypeError("Sparse arrays and accessors are not binary values");
+          visit(entry.value, depth + 1);
         }
-        else {
-            if (this.#errorHandler)
-                this.worker.off(this.#errorEvent, this.#errorHandler);
-            this.#errorHandler = fn;
-            this.worker.on(this.#errorEvent, fn);
+      } else {
+        const prototype = Object.getPrototypeOf(value2);
+        if (prototype !== Object.prototype && prototype !== null)
+          throw new TypeError("Binary maps must be plain objects");
+        const keys = Object.keys(value2).sort();
+        if (Object.getOwnPropertySymbols(value2).length)
+          throw new TypeError("Symbol keys are not binary values");
+        if (keys.length > limits.maxNodes - nodes)
+          throw new RangeError("Binary map exceeds node limit");
+        reserve(1 + varUintLength(keys.length));
+        plan.push(10, keys.length);
+        for (const key of keys) {
+          const entry = Object.getOwnPropertyDescriptor(value2, key);
+          if (!("value" in entry))
+            throw new TypeError("Accessors are not binary values");
+          string(key, 11);
+          visit(entry.value, depth + 1);
         }
+      }
+    } finally {
+      ancestors.delete(value2);
     }
-    /**
-     *
-     * @param {*} data
-     * @returns {Promise} resolves result onmessage & rejects on error
-     */
-    once(data) {
-        return new Promise((resolve, reject) => {
-            if (this.#isBrowser) {
-                const handleMessage = ({ data: result }) => {
-                    this.worker.onerror = null;
-                    resolve(result);
-                    this.terminate();
-                };
-                const handleError = (error) => {
-                    this.worker.onmessage = null;
-                    reject(error);
-                    this.terminate();
-                };
-                this.worker.onmessage = handleMessage;
-                this.worker.onerror = handleError;
-            }
-            else {
-                const handleMessage = (result) => {
-                    this.worker.off(this.#errorEvent, handleError);
-                    resolve(result);
-                    this.terminate();
-                };
-                const handleError = (error) => {
-                    this.worker.off(this.#messageEvent, handleMessage);
-                    reject(error);
-                    this.terminate();
-                };
-                this.worker.once(this.#messageEvent, handleMessage);
-                this.worker.once(this.#errorEvent, handleError);
-            }
-            this.postMessage(data);
-        });
+  };
+  visit(value, 0);
+  const capacity = prefix.length + size2;
+  if (!Number.isSafeInteger(capacity))
+    throw new RangeError("Binary output is too large");
+  const output = new Uint8Array(capacity);
+  output.set(prefix);
+  output.set(MAGIC, prefix.length);
+  let position = prefix.length + MAGIC.length;
+  let view;
+  const uint = (value2) => {
+    while (value2 >= 128) {
+      output[position++] = value2 % 128 | 128;
+      value2 = Math.floor(value2 / 128);
+    }
+    output[position++] = value2;
+  };
+  for (let cursor = 0; cursor < plan.length; ) {
+    const tag = plan[cursor++];
+    if (tag !== 11)
+      output[position++] = tag;
+    if (tag < 4)
+      continue;
+    if (tag === 4) {
+      view ??= new DataView(output.buffer);
+      view.setFloat64(position, plan[cursor++], false);
+      position += 8;
+    } else if (tag === 5 || tag === 6) {
+      let value2 = plan[cursor++];
+      while (value2 >= BIGINT_LIMB) {
+        let limb = Number(value2 & BIGINT_MASK);
+        for (let index = 0; index < 7; index++) {
+          output[position++] = limb % 128 | 128;
+          limb = Math.floor(limb / 128);
+        }
+        value2 >>= 49n;
+      }
+      uint(Number(value2));
+    } else if (tag === 7 || tag === 11) {
+      const value2 = plan[cursor++];
+      const length = plan[cursor++];
+      uint(length);
+      if (length === value2.length) {
+        for (let index = 0; index < length; index++)
+          output[position++] = value2.charCodeAt(index);
+      } else {
+        const result = utf8.encodeInto(value2, output.subarray(position, position + length));
+        if (result.read !== value2.length || result.written !== length)
+          throw new Error("UTF-8 planning mismatch");
+        position += length;
+      }
+    } else if (tag === 8) {
+      const value2 = plan[cursor++];
+      const length = plan[cursor++];
+      if (value2.length !== length)
+        throw new RangeError("Byte input changed while encoding");
+      uint(length);
+      output.set(value2, position);
+      position += length;
+    } else {
+      uint(plan[cursor++]);
+    }
+  }
+  if (position !== capacity)
+    throw new Error("Binary planning mismatch");
+  return output;
+}
+function decodeValue(input, options = {}) {
+  const limits = limitsFor(options);
+  if (!(input instanceof Uint8Array))
+    throw new TypeError("Wire payload must be Uint8Array");
+  if (input.length > limits.maxBytes)
+    throw new RangeError("Binary value exceeds byte limit");
+  const reader = new BinaryReader(input);
+  if (reader.readBytes(MAGIC.length).some((byte, index) => byte !== MAGIC[index]))
+    throw new TypeError("Unsupported binary wire version");
+  let nodes = 0;
+  const string = () => text$1.decode(reader.readFrame());
+  const read = (depth) => {
+    if (++nodes > limits.maxNodes || depth > limits.maxDepth)
+      throw new RangeError("Binary value exceeds complexity limit");
+    const tag = reader.readBytes(1)[0];
+    if (tag === 0)
+      return void 0;
+    if (tag === 1)
+      return null;
+    if (tag === 2)
+      return false;
+    if (tag === 3)
+      return true;
+    if (tag === 4) {
+      const bytes2 = reader.readBytes(8);
+      const value2 = new DataView(bytes2.buffer, bytes2.byteOffset, 8).getFloat64(0, false);
+      if (!Number.isFinite(value2))
+        throw new TypeError("Binary numbers must be finite");
+      return value2;
+    }
+    if (tag === 5 || tag === 6) {
+      const value2 = reader.readVarBigInt();
+      if (tag === 6 && value2 === 0n)
+        throw new TypeError("Non-canonical negative zero");
+      return tag === 6 ? -value2 : value2;
+    }
+    if (tag === 7)
+      return string();
+    if (tag === 8)
+      return new Uint8Array(reader.readFrame());
+    if (tag === 9 || tag === 10) {
+      const count = reader.readVarUint();
+      if (count > limits.maxNodes - nodes || count > reader.remaining)
+        throw new RangeError("Invalid binary collection size");
+      if (tag === 9)
+        return Array.from({ length: count }, () => read(depth + 1));
+      const result = {};
+      let previous;
+      for (let index = 0; index < count; index++) {
+        const key = string();
+        if (previous !== void 0 && key <= previous)
+          throw new TypeError("Non-canonical binary map keys");
+        previous = key;
+        Object.defineProperty(result, key, { value: read(depth + 1), enumerable: true, writable: true, configurable: true });
+      }
+      return result;
+    }
+    throw new TypeError("Unknown binary value tag");
+  };
+  const value = read(0);
+  if (reader.remaining)
+    throw new TypeError("Trailing binary data");
+  return value;
+}
+const encodeWire = (channel, value, limits) => encodeValue([channel, value], limits);
+function decodeWire(channel, bytes2, limits) {
+  const envelope = decodeValue(bytes2, limits);
+  if (!Array.isArray(envelope) || envelope.length !== 2 || envelope[0] !== channel)
+    throw new TypeError("Wrong binary message channel");
+  return envelope[1];
+}
+class BinaryWorker {
+  #transport;
+  #errorHandler;
+  constructor(url, options = {}) {
+    const transport = new EasyWorker(url, { ...options, serialization: "advanced" });
+    if (transport && typeof transport.then === "function")
+      return transport.then((value) => {
+        this.#transport = value;
+        this.worker = value.worker;
+        return this;
+      });
+    this.#transport = transport;
+    this.worker = transport.worker;
+  }
+  postMessage(value) {
+    this.#transport.postMessage(encodeWire("worker", value));
+  }
+  onmessage(handler) {
+    this.#transport.onmessage((bytes2) => {
+      let value;
+      try {
+        value = decodeWire("worker", bytes2);
+      } catch (error) {
+        if (this.#errorHandler)
+          this.#errorHandler(error);
+        else
+          throw error;
+        return;
+      }
+      handler(value);
+    });
+  }
+  onerror(handler) {
+    this.#errorHandler = handler;
+    this.#transport.onerror(handler);
+  }
+  terminate() {
+    return this.#transport.terminate();
+  }
+  async once(value) {
+    let timer;
+    try {
+      return await new Promise((resolve, reject) => {
+        timer = setTimeout(() => reject(new Error("Binary worker request timed out")), 1e4);
+        this.onerror(reject);
+        this.onmessage(resolve);
+        this.postMessage(value);
+      });
+    } finally {
+      clearTimeout(timer);
+      this.terminate();
     }
+  }
 }
 
 class LeofcoinError extends Error {
@@ -3613,90 +4068,412 @@ class ExecutionError extends LeofcoinError {
 class ContractDeploymentError extends LeofcoinError {
   name = "ContractDeploymentError";
 }
-const isResolveError = (error) => error.name === "ResolveError";
-const isExecutionError = (error) => error.name === "ExecutionError";
 
-const debug$2 = createDebugger("leofcoin/machine");
-class Machine {
-  constructor(blocks) {
-    this.states = {
-      states: {},
-      lastBlock: {
-        index: -1,
-        hash: ""
-      },
-      accounts: {},
-      info: {
-        nativeCalls: BigInt(0),
-        nativeMints: BigInt(0),
-        nativeBurns: BigInt(0),
-        nativeTransfers: BigInt(0),
-        totalBurnAmount: BigInt(0),
-        totalMintAmount: BigInt(0),
-        totalTransferAmount: BigInt(0),
-        totalTransactions: BigInt(0),
-        totalBlocks: BigInt(0)
-      }
-    };
-    this.wantList = [];
-    this.ready = new Promise((resolve) => {
-      this.readyResolve = resolve;
-    });
-    this.init(blocks);
+const CHAIN_ID_SCHEMA = "leofcoin:chain-identity:v1";
+const GENESIS_CONTRACT_NAMES = ["contractFactory", "nativeToken", "nameService", "validators"];
+const assertChainId = (value) => {
+  if (typeof value !== "string" || !/^lfc:[0-9a-f]{64}$/.test(value))
+    throw new Error("Invalid chain ID; expected lfc: followed by 64 lowercase hex characters");
+  return value;
+};
+const createChainIdentity = async (network, contracts) => {
+  if (typeof network !== "string" || !/^[a-z0-9][a-z0-9:-]{0,79}$/.test(network))
+    throw new Error("Invalid genesis network namespace");
+  const genesisContracts = {};
+  for (const name of GENESIS_CONTRACT_NAMES) {
+    const hash = contracts?.[name];
+    if (typeof hash !== "string" || !/^[A-Z2-7]{32,128}$/.test(hash))
+      throw new Error(`Invalid genesis contract hash: ${name}`);
+    genesisContracts[name] = hash;
   }
-  init(blocks) {
-    return this.#init(blocks);
+  const bytes = new TextEncoder().encode(JSON.stringify({ schema: CHAIN_ID_SCHEMA, network, genesisContracts }));
+  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
+  const chainId = "lfc:" + [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  return { schema: CHAIN_ID_SCHEMA, chainId, network, genesisContracts };
+};
+const verifyChainIdentity = async (value) => {
+  const identity = value;
+  if (!identity || identity.schema !== CHAIN_ID_SCHEMA)
+    throw new Error("Unsupported chain identity response");
+  const verified = await createChainIdentity(identity.network, identity.genesisContracts);
+  if (verified.chainId !== assertChainId(identity.chainId))
+    throw new Error("Chain ID does not match its genesis contracts");
+  return verified;
+};
+const findChainPresence = async (chainId, peerIds, requestIdentity, timeoutMs = 3e3) => {
+  assertChainId(chainId);
+  const peers = [...new Set(peerIds)].slice(0, 16);
+  const matches = [];
+  let responded = 0;
+  let unavailable = 0;
+  await Promise.all(peers.map(async (peerId) => {
+    let timer;
+    try {
+      const result = await Promise.race([
+        Promise.resolve().then(() => requestIdentity(peerId)),
+        new Promise((_, reject) => {
+          timer = setTimeout(() => reject(new Error("Chain identity request timed out")), timeoutMs);
+        })
+      ]);
+      const identity = await verifyChainIdentity(result);
+      responded++;
+      if (identity.chainId === chainId)
+        matches.push(peerId);
+    } catch {
+      unavailable++;
+    } finally {
+      clearTimeout(timer);
+    }
+  }));
+  return {
+    chainId,
+    status: matches.length ? "found" : !peers.length || unavailable ? "unknown" : "not-observed",
+    checkedPeers: peers.length,
+    respondedPeers: responded,
+    unavailablePeers: unavailable,
+    matchingPeers: matches.sort(),
+    scope: "reachable peers only; offline or undiscovered chains may still exist"
+  };
+};
+
+const validateChainLink = (localTip, incoming) => {
+  const localHash = localTip?.hash || "0x0";
+  const localIndex = Number(localTip?.index ?? -1);
+  const hasCanonicalTip = localHash !== "0x0";
+  if (hasCanonicalTip && incoming.index < localIndex) return "stale";
+  if (hasCanonicalTip && incoming.index === localIndex) {
+    if (incoming.hash === localHash) return "duplicate";
+    throw new Error(`Block conflict detected at index ${incoming.index}`);
   }
-  async #onmessage(data) {
-    switch (data.type) {
-      case "transactionLoaded": {
-        const { from, nonce, hash } = data.result;
-        await transactionPoolStore.has(hash) && await transactionPoolStore.delete(hash);
-        try {
-          const _nonce = await accountsStore.get(from);
-          if (nonce > _nonce) await accountsStore.put(from, nonce);
-        } catch (error) {
-          await accountsStore.put(from, nonce);
-        }
-        break;
-      }
-      case "contractError": {
-        console.warn(data.error);
-        console.warn(`contract error: ${data.hash}`);
-        await contractStore.delete(data.hash);
-        break;
-      }
-      case "initError": {
-        console.error(`init error: ${data.message}`);
-        break;
-      }
-      case "executeError": {
-        pubsub.publish(data.id, { error: data.message });
-        break;
-      }
-      case "addLoadedBlockError":
-      case "collectFeeError":
-      case "settleRewardsError": {
-        pubsub.publish(data.id, { error: new Error(data.message) });
-        break;
-      }
-      case "debug": {
-        if (data.message.includes("loaded transactions for block:")) {
-          pubsub.publish("block-loaded", data.message.replace("loaded transactions for block: ", "").split(" @")[0]);
+  const expectedIndex = hasCanonicalTip ? localIndex + 1 : 0;
+  if (incoming.index !== expectedIndex) {
+    throw new Error(`Unexpected block index ${incoming.index}; expected ${expectedIndex}`);
+  }
+  if (incoming.previousHash !== localHash) {
+    throw new Error(
+      `previousHash mismatch at index ${incoming.index}: expected ${localHash}, got ${incoming.previousHash}`
+    );
+  }
+  return "append";
+};
+
+const CHECKPOINT_KEYS = ["checkpoint:0", "checkpoint:1"];
+const counters = [
+  "nativeCalls",
+  "nativeMints",
+  "nativeBurns",
+  "nativeTransfers",
+  "totalBurnAmount",
+  "totalMintAmount",
+  "totalTransferAmount",
+  "totalTransactions",
+  "totalBlocks"
+];
+const record = (value) => value && typeof value === "object" && !Array.isArray(value);
+const text = (value) => typeof value === "string" ? value : new TextDecoder("utf-8", { fatal: true }).decode(value);
+const digest = async (value) => [...new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value)))].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+function validateCheckpoint(snapshot, chainId, requiredContracts) {
+  if (!record(snapshot) || snapshot.chainId !== chainId || !record(snapshot.states) || !record(snapshot.accounts) || !record(snapshot.info))
+    throw new Error("Invalid checkpoint or chain identity");
+  const tip = snapshot.lastBlock;
+  const index = Number(tip?.index);
+  if (!["bigint", "number"].includes(typeof tip?.index) || !Number.isSafeInteger(index) || index < -1 || (index === -1 ? tip.hash !== "0x0" : typeof tip.hash !== "string" || !tip.hash || tip.hash === "0x0"))
+    throw new Error("Invalid checkpoint tip");
+  for (const contract of requiredContracts) if (!record(snapshot.states[contract])) throw new Error(`Incomplete checkpoint contract: ${contract}`);
+  for (const [address, nonce] of Object.entries(snapshot.accounts))
+    if (!address || typeof nonce !== "string" || !/^(0|[1-9]\d*)$/.test(nonce)) throw new Error("Invalid checkpoint nonce");
+  for (const counter of counters)
+    if (typeof snapshot.info[counter] !== "bigint" || snapshot.info[counter] < 0n) throw new Error(`Invalid checkpoint counter: ${counter}`);
+  if (snapshot.info.totalBlocks !== BigInt(index) + 1n) throw new Error("Checkpoint block count does not match tip");
+  return snapshot;
+}
+async function writeCheckpoint(store, snapshot, generation, requiredContracts) {
+  if (!Number.isSafeInteger(generation) || generation < 0) throw new Error("Invalid checkpoint generation");
+  validateCheckpoint(snapshot, snapshot.chainId, requiredContracts);
+  const payload = JSON.stringify({ generation, snapshot }, jsonStringifyBigInt);
+  await store.put(CHECKPOINT_KEYS[generation % 2], new TextEncoder().encode(JSON.stringify({ schema: 1, payload, checksum: await digest(payload) })));
+}
+async function readCheckpoint(store, chainId, requiredContracts) {
+  const valid = [];
+  let present = 0;
+  const keys = new Set(await store.keys());
+  for (const key of CHECKPOINT_KEYS) {
+    if (!keys.has(key)) continue;
+    present++;
+    const bytes = await store.get(key);
+    try {
+      const envelope = JSON.parse(text(bytes));
+      if (envelope.schema !== 1 || typeof envelope.payload !== "string" || envelope.checksum !== await digest(envelope.payload)) throw new Error("Invalid checkpoint checksum");
+      const result = JSON.parse(envelope.payload, jsonParseBigInt);
+      if (!Number.isSafeInteger(result.generation) || result.generation < 0 || result.generation % 2 !== CHECKPOINT_KEYS.indexOf(key)) throw new Error("Invalid checkpoint generation");
+      validateCheckpoint(result.snapshot, chainId, requiredContracts);
+      valid.push(result);
+    } catch {
+    }
+  }
+  if (present && !valid.length) throw new Error("No valid state checkpoint remains; preserve this data root and rebuild in a separate root");
+  return valid.sort((left, right) => right.generation - left.generation)[0];
+}
+async function recoveryHistory(hash, readBlock) {
+  const reversed = [];
+  const seen = /* @__PURE__ */ new Set();
+  while (hash !== "0x0") {
+    if (!hash || seen.has(hash)) throw new Error("Invalid or cyclic recovery ancestry");
+    seen.add(hash);
+    const bytes = await readBlock(hash);
+    if (!bytes) throw new Error(`Recovery block unavailable: ${hash}`);
+    const message = new BlockMessage(bytes);
+    if (await message.hash() !== hash) throw new Error(`Recovery block hash mismatch: ${hash}`);
+    reversed.push({ ...message.decoded, hash, loaded: false });
+    hash = message.decoded.previousHash;
+  }
+  const history = reversed.reverse();
+  let tip = { index: -1, hash: "0x0" };
+  for (const block of history) {
+    const index = Number(block.index);
+    if (!Number.isSafeInteger(index) || index < 0) throw new Error("Invalid recovery block index");
+    if (validateChainLink(tip, { index, hash: block.hash, previousHash: block.previousHash }) !== "append") throw new Error("Invalid recovery chain link");
+    tip = { index, hash: block.hash };
+  }
+  return history;
+}
+async function restoreAccountNonces(store, accounts) {
+  await store.clear();
+  for (const [address, nonce] of Object.entries(accounts)) await store.put(address, String(nonce));
+}
+
+class ReadOnlyMachine {
+  constructor(workerPath, readContract) {
+    this.workerPath = workerPath;
+    this.readContract = readContract;
+  }
+  #worker;
+  #pending = /* @__PURE__ */ new Map();
+  #tail = Promise.resolve();
+  #queued = 0;
+  #seed;
+  #cache = /* @__PURE__ */ new Map();
+  #cacheBytes = 0;
+  #closed = false;
+  read(seed, contract, method, params = [], sender = "leofcoin:read-only") {
+    if (this.#closed) return Promise.reject(new Error("Read-only machine is closed"));
+    if (typeof contract !== "string" || !contract || typeof method !== "string" || !method || ["constructor", "__proto__", "prototype"].includes(method) || !Array.isArray(params))
+      return Promise.reject(new Error("Invalid read-only contract query"));
+    if (this.#queued >= 32) return Promise.reject(new Error("Read-only query queue is full"));
+    let key;
+    try {
+      key = JSON.stringify({ contract, method, params, sender }, jsonStringifyBigInt);
+      if (new TextEncoder().encode(key).byteLength > 65536) throw new Error("Read-only query is too large");
+      params = structuredClone(params);
+    } catch (error) {
+      return Promise.reject(error);
+    }
+    this.#queued++;
+    const result = this.#tail.then(async () => {
+      if (this.#closed) throw new Error("Read-only machine is closed");
+      if (this.#seed !== seed) {
+        this.#seed = seed;
+        this.#cache.clear();
+        this.#cacheBytes = 0;
+      }
+      if (this.#cache.has(key)) return structuredClone(this.#cache.get(key).value);
+      try {
+        await this.#start();
+        const initialized = await this.#request("init", {
+          readOnly: true,
+          fromState: true,
+          blocks: [],
+          peerid: "leofcoin:read-only",
+          lastBlock: seed.lastBlock,
+          state: seed.states,
+          info: seed.info
+        });
+        if (initialized !== true) throw new Error("Worker does not support isolated contract queries");
+        const value = await this.#request("read", { contract, method, params, sender });
+        const bytes = new TextEncoder().encode(JSON.stringify(value, jsonStringifyBigInt) ?? "").byteLength;
+        if (bytes > 4 * 1024 * 1024) throw new Error("Read-only result is too large");
+        while (this.#cache.size && (this.#cache.size >= 64 || this.#cacheBytes + bytes > 4 * 1024 * 1024)) {
+          const oldest = this.#cache.keys().next().value;
+          this.#cacheBytes -= this.#cache.get(oldest).bytes;
+          this.#cache.delete(oldest);
+        }
+        this.#cache.set(key, { value: structuredClone(value), bytes });
+        this.#cacheBytes += bytes;
+        return value;
+      } catch (error) {
+        this.#stop();
+        throw error;
+      }
+    });
+    this.#tail = result.then(() => void 0, () => void 0);
+    return result.finally(() => {
+      this.#queued--;
+    });
+  }
+  async #start() {
+    if (this.#worker) return;
+    const worker = await new BinaryWorker(this.workerPath, { serialization: "advanced", type: "module" });
+    if (this.#closed) {
+      worker.terminate();
+      throw new Error("Read-only machine is closed");
+    }
+    this.#worker = worker;
+    worker.onmessage(async (message) => {
+      if (this.#worker !== worker) return;
+      if (message.type === "ask") {
+        try {
+          const input = message.question === "peers" ? [] : message.question === "contract" ? await this.readContract(message.input) : void 0;
+          if (this.#worker === worker) worker.postMessage({ id: message.id, input });
+        } catch {
+          if (this.#worker === worker) worker.postMessage({ id: message.id, input: void 0 });
         }
+        return;
+      }
+      const pending = this.#pending.get(message.id);
+      if (!pending) return;
+      if (message.type !== "response" && !["initError", "readError"].includes(message.type)) return;
+      clearTimeout(pending.timer);
+      this.#pending.delete(message.id);
+      if (message.type === "response") pending.resolve(message.value);
+      else pending.reject(new Error(message.message || "Read-only worker failed"));
+    });
+    worker.onerror(() => {
+      if (this.#worker === worker) this.#stop();
+    });
+    worker.worker?.once?.("exit", () => {
+      if (this.#worker === worker) this.#stop();
+    });
+  }
+  #request(type, input) {
+    return new Promise((resolve, reject) => {
+      const id = crypto.randomUUID();
+      const timer = setTimeout(() => this.#stop(new Error("Read-only query timed out")), 1e4);
+      this.#pending.set(id, { resolve, reject, timer });
+      try {
+        this.#worker.postMessage({ id, type, input });
+      } catch (error) {
+        this.#stop(error);
+      }
+    });
+  }
+  #stop(error = new Error("Read-only worker stopped")) {
+    const worker = this.#worker;
+    this.#worker = void 0;
+    for (const pending of this.#pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.#pending.clear();
+    worker?.terminate();
+  }
+  close() {
+    this.#closed = true;
+    this.#cache.clear();
+    this.#cacheBytes = 0;
+    this.#seed = void 0;
+    this.#stop();
+  }
+}
+
+const genesisContracts = {
+  contractFactory: addresses.contractFactory,
+  nativeToken: addresses.nativeToken,
+  nameService: addresses.nameService,
+  validators: addresses.validators
+};
+const debug$2 = createDebugger("leofcoin/machine");
+class Machine {
+  constructor(blocks = [], checkpoint) {
+    this.states = {
+      states: {},
+      lastBlock: {
+        index: -1,
+        hash: "0x0"
+      },
+      accounts: {},
+      info: {
+        nativeCalls: BigInt(0),
+        nativeMints: BigInt(0),
+        nativeBurns: BigInt(0),
+        nativeTransfers: BigInt(0),
+        totalBurnAmount: BigInt(0),
+        totalMintAmount: BigInt(0),
+        totalTransferAmount: BigInt(0),
+        totalTransactions: BigInt(0),
+        totalBlocks: BigInt(0)
+      }
+    };
+    this.wantList = [];
+    this.ready = new Promise((resolve, reject) => {
+      this.readyResolve = resolve;
+      this.readyReject = reject;
+    });
+    this.#checkpointGeneration = -1;
+    this.#closed = false;
+    this.init(blocks, checkpoint).then(() => this.readyResolve(this), (error) => {
+      this.close();
+      this.readyReject(error);
+    });
+  }
+  #checkpointGeneration;
+  #chainId;
+  #reader;
+  #contractReader;
+  #readSnapshot;
+  #workerPath;
+  #closed;
+  close() {
+    this.#closed = true;
+    this.#reader?.close();
+    this.#contractReader?.close();
+    this.worker?.terminate();
+  }
+  async init(blocks, checkpoint) {
+    return this.#init(blocks, checkpoint);
+  }
+  async #onmessage(data) {
+    if (this.#closed) return;
+    switch (data.type) {
+      case "contractError": {
+        console.warn(data.message ?? data.error);
+        console.warn(`contract error: ${data.hash}`);
         break;
       }
-      case "error": {
-        console.error(data.message);
+      case "initError": {
+        pubsub.publish(data.id, { error: new Error(`Machine initialization failed: ${data.message}`) });
+        break;
+      }
+      case "executeError": {
+        pubsub.publish(data.id, { error: data.message });
+        break;
+      }
+      case "addLoadedBlockError":
+      case "runContractError":
+      case "collectFeeError":
+      case "settleRewardsError": {
+        pubsub.publish(data.id, { error: new Error(data.message) });
         break;
       }
-      case "machine-ready": {
-        this.readyResolve(this);
-        pubsub.publish("machine.ready", true);
+      case "snapshotError": {
+        pubsub.publish(data.id, { error: new Error(data.message) });
+        break;
+      }
+      case "getError": {
+        pubsub.publish(data.id, { error: new Error(data.message) });
+        break;
+      }
+      case "debug": {
+        if (data.message.includes("loaded transactions for block:")) {
+          pubsub.publish("block-loaded", data.message.replace("loaded transactions for block: ", "").split(" @")[0]);
+        }
+        break;
+      }
+      case "error": {
+        console.error(data.message);
         break;
       }
       case "response": {
-        pubsub.publish(data.id, data.value || false);
+        pubsub.publish(data.id, data.value ?? false);
         break;
       }
       case "addToWantList": {
@@ -3704,6 +4481,16 @@ class Machine {
         break;
       }
       case "ask": {
+        if (data.question === "staticCall") {
+          try {
+            const { snapshot, contract, method, params, sender } = data.input;
+            const input = await this.#contractReader.read(snapshot, contract, method, params, sender);
+            if (!this.#closed) this.worker.postMessage({ id: data.id, input });
+          } catch (error) {
+            if (!this.#closed) this.worker.postMessage({ id: data.id, error: error instanceof Error ? error.message : String(error) });
+          }
+          break;
+        }
         if (data.question === "contract" || data.question === "transaction") {
           try {
             const input = await peernet.get(data.input, data.question);
@@ -3731,164 +4518,61 @@ class Machine {
   }
   async updateState(strict = false) {
     try {
-      const lastBlock = strict ? await this.getCanonicalTip() : await this.lastBlock;
-      const lastBlockIndex = Number(lastBlock.index);
-      const statesLastBlockIndex = Number(this.states.lastBlock.index);
-      if (lastBlockIndex > statesLastBlockIndex || lastBlock.hash !== this.states.lastBlock.hash && Number(lastBlockIndex) === 0) {
-        const blocks = (await this.blocks).slice(statesLastBlockIndex);
-        let transactions = [];
-        for (const block of blocks) {
-          if (block?.transactions) transactions = [...transactions, ...block.transactions];
-        }
-        transactions = await Promise.all(
-          transactions.map(async (transaction) => new TransactionMessage(await transactionStore.get(transaction)))
-        );
-        const contractsToGet = transactions.reduce((set, current) => {
-          const contract = current.decoded.to;
-          if (!set.includes(contract)) set.push(contract);
-          return set;
-        }, []);
-        const state = {};
-        if (!contractsToGet.includes(addresses.contractFactory)) contractsToGet.push(addresses.contractFactory);
-        if (!contractsToGet.includes(addresses.nativeToken)) contractsToGet.push(addresses.nativeToken);
-        if (!contractsToGet.includes(addresses.nameService)) contractsToGet.push(addresses.nameService);
-        if (!contractsToGet.includes(addresses.validators)) contractsToGet.push(addresses.validators);
-        await Promise.all(
-          contractsToGet.map(async (contract) => {
-            const value = await this.#askWorker("get", { contract, method: "state", params: [] });
-            state[contract] = value;
-          })
-        );
-        let accounts = {};
-        try {
-          const promises = [];
-          for (const address of await accountsStore.keys()) {
-            promises.push(
-              (async () => {
-                accounts[address] = await accountsStore.get(address);
-              })()
-            );
-          }
-          await Promise.all(promises);
-        } catch (error) {
-          const promises = [];
-          for (const transaction of transactions.reverse()) {
-            const { from, to, amount, nonce } = transaction.decoded.data;
-            if (!accounts[from]) {
-              accounts[from] = nonce;
-              promises.push(accountsStore.put(from, nonce));
-            }
-          }
-          await Promise.all(promises);
-        }
-        const sortedStringify = (obj, replacer) => {
-          const sorted = {};
-          const keys = Object.keys(obj).sort();
-          for (const key of keys) {
-            sorted[key] = obj[key];
-          }
-          return JSON.stringify(sorted, replacer);
-        };
-        const tasks = [
-          stateStore.put("lastBlock", sortedStringify(lastBlock, jsonStringifyBigInt)),
-          stateStore.put("states", sortedStringify(state, jsonStringifyBigInt)),
-          stateStore.put("accounts", sortedStringify(accounts, jsonStringifyBigInt)),
-          stateStore.put(
-            "info",
-            sortedStringify(
-              {
-                nativeBurnAmount: await this.totalBurnAmount,
-                nativeBurns: await this.nativeBurns,
-                nativeCalls: await this.nativeCalls,
-                nativeMints: await this.nativeMints,
-                nativeTransfers: await this.nativeTransfers,
-                totalBlocks: await blockStore.length,
-                totalBurnAmount: await this.totalBurnAmount,
-                totalMintAmount: await this.totalMintAmount,
-                totalTransactions: await this.totalTransactions,
-                totalTransferAmount: await this.totalTransferAmount
-              },
-              jsonStringifyBigInt
-            )
-          )
-          // accountsStore.clear()
-        ];
-        await Promise.all(tasks);
+      const snapshot = await this.#askWorker("snapshot");
+      snapshot.chainId = this.#chainId;
+      const accounts = {};
+      for (const address of await accountsStore.keys()) {
+        const raw = await accountsStore.get(address);
+        accounts[address] = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
       }
+      snapshot.accounts = accounts;
+      const generation = this.#checkpointGeneration + 1;
+      await writeCheckpoint(stateStore, snapshot, generation, Object.values(genesisContracts));
+      this.#checkpointGeneration = generation;
+      this.states = snapshot;
+      this.#readSnapshot = structuredClone(snapshot);
     } catch (error) {
-      console.error(error);
       if (strict) throw error;
+      console.error(error);
+      throw error;
     }
   }
-  async #init(blocks) {
-    return new Promise(async (resolve) => {
-      const machineReady = async () => {
-        pubsub.unsubscribe("machine.ready", machineReady);
-        await this.updateState();
-        resolve(this);
-      };
-      pubsub.subscribe("machine.ready", machineReady);
-      let pre;
-      try {
-        const importee = await import('url');
-        const url = importee.default;
-        if (url) pre = url.fileURLToPath(new URL(".", import.meta.url));
-      } catch {
-        pre = "./";
-      }
-      this.worker = await new EasyWorker(pre + "workers/machine-worker.js", {
-        serialization: "advanced",
-        type: "module"
-      });
-      this.worker.onmessage(this.#onmessage.bind(this));
-      let rawLastBlock;
-      let rawStates;
-      let rawAccounts;
-      let rawInfo;
-      if (await stateStore.has("lastBlock")) {
-        const decoder = new TextDecoder();
-        const decode = (param) => decoder.decode(param);
-        rawLastBlock = decode(await stateStore.get("lastBlock"));
-        this.states.lastBlock = JSON.parse(rawLastBlock, jsonParseBigInt);
-        try {
-          rawStates = decode(await stateStore.get("states"));
-          rawAccounts = decode(await stateStore.get("accounts"));
-          rawInfo = decode(await stateStore.get("info"));
-          this.states.states = JSON.parse(rawStates, jsonParseBigInt);
-          this.states.accounts = JSON.parse(rawAccounts, jsonParseBigInt);
-          this.states.info = JSON.parse(rawInfo, jsonParseBigInt);
-        } catch (error) {
-          console.error(error);
-          this.states.accounts = {};
-          this.states.info = {
-            nativeCalls: BigInt(0),
-            nativeMints: BigInt(0),
-            nativeBurns: BigInt(0),
-            nativeTransfers: BigInt(0),
-            totalBurnAmount: BigInt(0),
-            totalMintAmount: BigInt(0),
-            totalTransferAmount: BigInt(0),
-            totalTransactions: BigInt(0),
-            totalBlocks: BigInt(0)
-          };
-          rawInfo = JSON.stringify(this.states.info, jsonStringifyBigInt);
-          await stateStore.put("info", new TextEncoder().encode(rawInfo));
-        }
-      }
-      const message = {
-        type: "init",
-        input: {
-          blocks,
-          fromState: this.states.lastBlock?.index >= 0,
-          lastBlock: rawLastBlock,
-          state: rawStates,
-          info: rawInfo,
-          // @ts-ignore
-          peerid: peernet.peerId
-        }
-      };
-      this.worker.postMessage(message);
+  async #init(blocks, checkpoint) {
+    const identity = await createChainIdentity(globalThis.peernet?.network || "leofcoin:peach", addresses);
+    this.#chainId = identity.chainId;
+    if (checkpoint) {
+      this.#checkpointGeneration = checkpoint.generation;
+      this.states = checkpoint.snapshot;
+    }
+    let pre = "./";
+    try {
+      const { fileURLToPath } = await import('url');
+      pre = fileURLToPath(new URL(".", import.meta.url));
+    } catch {
+    }
+    this.#workerPath = pre + "workers/machine-worker.js";
+    const readContract = (hash) => globalThis.contractStore.get(hash);
+    this.#reader = new ReadOnlyMachine(this.#workerPath, readContract);
+    this.#contractReader = new ReadOnlyMachine(this.#workerPath, readContract);
+    this.worker = await new BinaryWorker(this.#workerPath, {
+      serialization: "advanced",
+      type: "module"
+    });
+    if (this.#closed) {
+      this.worker.terminate();
+      throw new Error("State machine is closed");
+    }
+    this.worker.onmessage(this.#onmessage.bind(this));
+    const initialized = await this.#askWorker("init", {
+      blocks,
+      fromState: Boolean(checkpoint),
+      lastBlock: checkpoint?.snapshot.lastBlock,
+      state: checkpoint?.snapshot.states,
+      info: checkpoint?.snapshot.info,
+      peerid: peernet.peerId
     });
+    if (initialized !== true) throw new Error("Worker does not support checkpoint initialization; deploy matching chain and worker builds");
+    this.#readSnapshot = structuredClone(checkpoint?.snapshot ?? await this.#askWorker("snapshot"));
   }
   async #runContract(contractMessage) {
     const hash = await contractMessage.hash();
@@ -3919,6 +4603,7 @@ class Machine {
    * @returns Promise<message>
    */
   async execute(contract, method, parameters, sender, execution) {
+    if (this.#closed) throw new Error("State machine is closed");
     try {
       if (contract === contractFactory && method === "registerContract") {
         if (await this.has(parameters[0])) throw new Error(`duplicate contract @${parameters[0]}`);
@@ -3975,28 +4660,8 @@ ${error.message}`);
     return this.#askWorker("settleRewards", { rewards });
   }
   get(contract, method, parameters) {
-    return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString();
-      const timeout = setTimeout(() => {
-        pubsub.unsubscribe(id, onmessage);
-        reject(new Error(`Machine.get timeout for ${contract}.${method}`));
-      }, 3e4);
-      const onmessage = (message) => {
-        clearTimeout(timeout);
-        pubsub.unsubscribe(id, onmessage);
-        resolve(message);
-      };
-      pubsub.subscribe(id, onmessage);
-      this.worker.postMessage({
-        type: "get",
-        id,
-        input: {
-          contract,
-          method,
-          params: parameters
-        }
-      });
-    });
+    if (!this.#readSnapshot) return Promise.reject(new Error("Contract read state is not initialized"));
+    return this.#reader.read(this.#readSnapshot, contract, method, parameters ?? []);
   }
   async has(address) {
     return new Promise((resolve, reject) => {
@@ -4022,6 +4687,7 @@ ${error.message}`);
     });
   }
   #askWorker(type, input) {
+    if (this.#closed) return Promise.reject(new Error("State machine is closed"));
     return new Promise((resolve, reject) => {
       const id = randombytes(20).toString("hex");
       const timeout = setTimeout(() => {
@@ -4079,19 +4745,13 @@ ${error.message}`);
     return this.getBlocks();
   }
   get lastBlock() {
-    return this.#askWorker("lastBlock").catch((error) => {
-      debug$2("lastBlock fallback after worker timeout:", error?.message ?? error);
-      return this.states.lastBlock;
-    });
+    return Promise.resolve(this.states.lastBlock);
   }
   getCanonicalTip() {
     return this.#askWorker("lastBlock");
   }
   get lastBlockHeight() {
-    return this.#askWorker("lastBlockHeight").catch((error) => {
-      debug$2("lastBlockHeight fallback after worker timeout:", error?.message ?? error);
-      return Number(this.states.lastBlock?.index ?? 0);
-    });
+    return Promise.resolve(Number(this.states.lastBlock.index));
   }
   getBlocks(from, to) {
     return this.#askWorker("blocks", { from, to });
@@ -4102,7 +4762,7 @@ ${error.message}`);
   async addLoadedBlock(block) {
     debug$2(`adding loaded block: ${block.index}@${block.hash}`);
     if (block.decoded) block = { ...block.decoded, hash: await block.hash() };
-    return this.#askWorker("addLoadedBlock", JSON.stringify(block, jsonStringifyBigInt));
+    return this.#askWorker("addLoadedBlock", block);
   }
   async latestTransactions() {
     return this.#askWorker("latestTransactions");
@@ -4150,91 +4810,19 @@ class Jobber {
   }
 }
 
-const MAX_RESPONSE_DEPTH$1 = 3;
-const asLastBlockMessage = async (blockInput, claimedHash) => {
-  const block = new BlockMessage(blockInput);
-  const hash = await block.hash();
-  if (claimedHash && hash !== claimedHash) {
-    throw new Error(`lastBlock hash mismatch: expected ${claimedHash}, got ${hash}`);
-  }
-  return new LastBlockMessage({ hash, index: block.decoded.index });
-};
-const resolveLegacyHash = async (hash) => {
-  const blockData = await globalThis.peernet?.get?.(hash, "block");
-  if (!blockData) throw new Error(`unable to resolve lastBlock hash: ${hash}`);
-  return asLastBlockMessage(blockData, hash);
-};
-const resolveLastBlockMessage = async (result, depth = 0) => {
-  if (depth > MAX_RESPONSE_DEPTH$1) throw new Error("lastBlock response nesting exceeds limit");
-  if (result instanceof Uint8Array) {
-    let codec;
-    try {
-      codec = new Codec(result);
-    } catch {
-    }
-    if (codec) {
-      if (codec.name === "peernet-response") {
-        const ResponseMessage = globalThis.peernet?.protos?.["peernet-response"];
-        if (!ResponseMessage) throw new Error("peernet-response codec is not registered");
-        const wrapped = new ResponseMessage(result);
-        if (wrapped?.decoded?.response === void 0) throw new Error("peernet-response has no response payload");
-        return resolveLastBlockMessage(wrapped.decoded.response, depth + 1);
-      }
-      if (codec.name === "last-block-message") return new LastBlockMessage(result);
-      if (codec.name === "block-message") return asLastBlockMessage(result);
-    }
-    const candidate = new TextDecoder().decode(result);
-    if (candidate) return resolveLegacyHash(candidate);
-  }
-  if (typeof result === "string") return resolveLegacyHash(result);
-  if (result && typeof result === "object") {
-    const response = result.decoded?.response ?? result.response;
-    if (response !== void 0) return resolveLastBlockMessage(response, depth + 1);
-    if ("hash" in result && "index" in result) return new LastBlockMessage(result);
-    if ("previousHash" in result && "index" in result) return asLastBlockMessage(result);
-  }
-  throw new Error(`invalid lastBlock payload: ${typeof result}`);
-};
-
-const MAX_RESPONSE_DEPTH = 3;
-const decodeResponsePayload = async (result, depth = 0) => {
-  if (depth > MAX_RESPONSE_DEPTH) throw new Error("peernet response nesting exceeds limit");
-  if (result instanceof Uint8Array) {
-    let codec;
-    try {
-      codec = new Codec(result);
-    } catch {
-    }
-    if (codec?.name === "peernet-response") {
-      const ResponseMessage = globalThis.peernet?.protos?.["peernet-response"];
-      if (!ResponseMessage) throw new Error("peernet-response codec is not registered");
-      const wrapped = new ResponseMessage(result);
-      return decodeResponsePayload(wrapped.decoded.response, depth + 1);
-    }
-    try {
-      return JSON.parse(new TextDecoder().decode(result));
-    } catch {
-      return result;
-    }
-  }
-  if (result && typeof result === "object") {
-    const response = result.decoded?.response ?? result.response;
-    if (response !== void 0) return decodeResponsePayload(response, depth + 1);
-  }
-  if (typeof result === "string") {
-    try {
-      return JSON.parse(result);
-    } catch {
-      return result;
-    }
-  }
-  return result;
+const resolveLastBlockMessage = async (result) => {
+  if (!(result instanceof Uint8Array) || new Codec(result).name !== "last-block-message")
+    throw new TypeError("lastBlock response must be a binary last-block message");
+  return new LastBlockMessage(result);
 };
 
 class CanonicalStateQueue {
   #tail = Promise.resolve();
   #failed = false;
   #failure;
+  get failed() {
+    return this.#failed;
+  }
   run(operation) {
     const result = this.#tail.then(async () => {
       if (this.#failed) {
@@ -4260,27 +4848,6 @@ class CanonicalStateQueue {
   }
 }
 
-const validateChainLink = (localTip, incoming) => {
-  const localHash = localTip?.hash || "0x0";
-  const localIndex = Number(localTip?.index ?? -1);
-  const hasCanonicalTip = localHash !== "0x0";
-  if (hasCanonicalTip && incoming.index < localIndex) return "stale";
-  if (hasCanonicalTip && incoming.index === localIndex) {
-    if (incoming.hash === localHash) return "duplicate";
-    throw new Error(`Block conflict detected at index ${incoming.index}`);
-  }
-  const expectedIndex = hasCanonicalTip ? localIndex + 1 : 0;
-  if (incoming.index !== expectedIndex) {
-    throw new Error(`Unexpected block index ${incoming.index}; expected ${expectedIndex}`);
-  }
-  if (incoming.previousHash !== localHash) {
-    throw new Error(
-      `previousHash mismatch at index ${incoming.index}: expected ${localHash}, got ${incoming.previousHash}`
-    );
-  }
-  return "append";
-};
-
 const resolveTransactionReference = async (expectedHash, transactionData) => {
   const transaction = transactionData instanceof TransactionMessage ? transactionData : new TransactionMessage(transactionData);
   const actualHash = await transaction.hash();
@@ -4290,6 +4857,41 @@ const resolveTransactionReference = async (expectedHash, transactionData) => {
   return transaction;
 };
 
+function publishObserverEvent(bus, topic, payload, onError = (topic2, error) => console.warn(`[chain observer] ${topic2}:`, error)) {
+  const report = (error) => {
+    try {
+      onError(topic, error);
+    } catch {
+    }
+  };
+  const invoke = (callback) => {
+    try {
+      const result = callback();
+      if (result && typeof result.then === "function") Promise.resolve(result).catch(report);
+    } catch (error) {
+      report(error);
+    }
+  };
+  try {
+    const value = structuredClone(payload);
+    if (!(bus.subscribers instanceof Map)) {
+      invoke(() => bus.publish(topic, value));
+      return;
+    }
+    let subscriber = bus.subscribers.get(topic);
+    if (!subscriber) {
+      subscriber = { handlers: [], value: void 0 };
+      bus.subscribers.set(topic, subscriber);
+    }
+    const oldValue = subscriber.value;
+    if (!bus.verbose && oldValue === value) return;
+    subscriber.value = value;
+    for (const handler of [...subscriber.handlers]) invoke(() => handler.bound(value, oldValue));
+  } catch (error) {
+    report(error);
+  }
+}
+
 const debug$1 = createDebugger("leofcoin/state");
 class State extends Contract {
   constructor(config) {
@@ -4323,15 +4925,6 @@ class State extends Contract {
         response: { blocks: await globalThis.blockStore.keys() }
       });
     };
-    this.#loadBlockTransactions = (transactions) => Promise.all(
-      transactions.map(async (transaction) => new TransactionMessage(await peernet.get(transaction, "transaction")))
-    );
-    this.#getLastTransactions = async () => {
-      let lastTransactions = (await Promise.all(
-        (await this.blocks).filter((block) => block.loaded).slice(-24).map((block) => this.#loadBlockTransactions(block.transactions))
-      )).reduce((all, transactions) => [...all, ...transactions], []);
-      return Promise.all(lastTransactions.map((transaction) => transaction.hash()));
-    };
   }
   #resolveErrored;
   #lastResolvedTime;
@@ -4349,7 +4942,13 @@ class State extends Contract {
   #machine;
   #canonicalStateQueue;
   withCanonicalState(operation) {
-    return this.#canonicalStateQueue.run(operation);
+    return this.#canonicalStateQueue.run(operation).catch((error) => {
+      if (this.#canonicalStateQueue.failed) {
+        this.#loaded = false;
+        this.#syncState = "errored";
+      }
+      throw error;
+    });
   }
   canonicalTip() {
     return this.#machine ? this.#machine.getCanonicalTip() : Promise.resolve({ index: -1, hash: "0x0", previousHash: "0x0" });
@@ -4449,91 +5048,79 @@ class State extends Contract {
   #lastBlockHandler;
   #knownBlocksHandler;
   async init() {
-    debug$1("State init start");
     this.jobber = new Jobber(this.resolveTimeout);
     await globalThis.peernet.addRequestHandler("lastBlock", this.#lastBlockHandler);
     await globalThis.peernet.addRequestHandler("knownBlocks", this.#knownBlocksHandler);
     await globalThis.peernet.addRequestHandler("chainState", this.#chainStateHandler);
-    let localBlockHash;
-    let blockMessage;
-    let localBlock;
-    console.log("State init before try-catch");
     try {
-      const rawBlock = await globalThis.chainStore.has("lastBlock");
-      console.log("State init after has lastBlock check");
-      if (rawBlock) {
-        console.log("State init after has lastBlock found");
-        console.log(rawBlock);
-        localBlockHash = new TextDecoder().decode(await globalThis.chainStore.get("lastBlock"));
-        console.log(localBlockHash);
-        if (localBlockHash !== "0x0") {
-          blockMessage = await globalThis.blockStore.get(localBlockHash);
-          console.log(blockMessage);
-          blockMessage = await new BlockMessage(blockMessage);
-          localBlock = { ...blockMessage.decoded, hash: localBlockHash };
-        }
-        console.log("State init after localBlock set");
-      } else {
-        localBlock = { index: 0, hash: "0x0", previousHash: "0x0" };
+      const identity = await createChainIdentity(globalThis.peernet?.network || "leofcoin:peach", addresses);
+      const required = [addresses.contractFactory, addresses.nativeToken, addresses.nameService, addresses.validators];
+      const checkpoint = await readCheckpoint(globalThis.stateStore, identity.chainId, required);
+      const checkpointTip = checkpoint?.snapshot.lastBlock ?? { index: -1, hash: "0x0" };
+      const marker = await globalThis.chainStore.has("lastBlock") ? new TextDecoder().decode(await globalThis.chainStore.get("lastBlock")) : "0x0";
+      const readBlock = async (hash) => await globalThis.blockStore.has(hash) ? globalThis.blockStore.get(hash) : globalThis.peernet.get(hash, "block");
+      let history = await recoveryHistory(checkpointTip.hash, readBlock);
+      if (marker !== "0x0" && marker !== checkpointTip.hash && !history.some((block) => block.hash === marker)) {
+        const candidate = await recoveryHistory(marker, readBlock);
+        if (checkpointTip.hash !== "0x0" && candidate[Number(checkpointTip.index)]?.hash !== checkpointTip.hash)
+          throw new Error("Persisted chain marker conflicts with state checkpoint");
+        history = candidate;
       }
-    } catch {
-      console.log("e");
-      console.log("State init middle");
-      localBlock = { index: 0, hash: "0x0", previousHash: "0x0" };
-    }
-    console.log("State init middle");
-    try {
-      console.log("fetching known blocks from blockStore");
-      this.knownBlocks = await globalThis.blockStore.keys();
-    } catch (error) {
-      console.log("no local known blocks found");
-    }
-    try {
-      if (localBlock?.hash && localBlock.hash !== "0x0") {
-        try {
-          if (!await globalThis.stateStore.has("lastBlock")) {
-            await this.resolveBlocks();
-          }
-        } catch {
-          await this.resolveBlocks();
+      if (!checkpoint && await globalThis.stateStore.has("lastBlock")) {
+        const legacy = JSON.parse(new TextDecoder().decode(await globalThis.stateStore.get("lastBlock")));
+        if (legacy.hash && legacy.hash !== "0x0" && legacy.hash !== history.at(-1)?.hash) {
+          const candidate = await recoveryHistory(legacy.hash, readBlock);
+          const common = Math.min(history.length, candidate.length);
+          if (common && history[common - 1].hash !== candidate[common - 1].hash)
+            throw new Error("Legacy snapshot conflicts with canonical chain marker");
+          if (candidate.length > history.length) history = candidate;
         }
-      } else {
-        await this.resolveBlocks();
       }
-      const machine = new Machine(this.#blocks);
-      console.log(machine);
+      if (await globalThis.chainStore.has("recoveryTarget")) {
+        const target = new TextDecoder().decode(await globalThis.chainStore.get("recoveryTarget"));
+        const candidate = await recoveryHistory(target, readBlock);
+        const common = Math.min(history.length, candidate.length);
+        if (common && history[common - 1].hash !== candidate[common - 1].hash)
+          throw new Error("Recovery target conflicts with canonical checkpoint history");
+        if (candidate.length > history.length) history = candidate;
+      }
+      this.#blocks = history;
+      this.#blockHashMap = new Map(history.map((block) => [block.hash, block.index]));
+      this.knownBlocks = await globalThis.blockStore.keys();
+      if (!checkpoint && !history.length && this.knownBlocks.length)
+        throw new Error("Local blocks exist without a canonical recovery anchor; preserve this root and rebuild in a separate root");
+      const prefix = history.slice(0, Number(checkpointTip.index) + 1).map((block) => ({ ...block, loaded: true }));
+      if (history.length > prefix.length) await globalThis.chainStore.put("recoveryTarget", history.at(-1).hash);
+      const machine = new Machine(prefix, checkpoint);
       await machine.ready;
       this.#machine = machine;
-      const lastBlock = await this.#machine.lastBlock;
-      if (lastBlock.hash !== "0x0") {
-        await this.updateState(new BlockMessage(lastBlock));
-      }
+      await restoreAccountNonces(globalThis.accountsStore, checkpoint?.snapshot.accounts ?? {});
+      for (const block of prefix) this.#blocks[Number(block.index)].loaded = true;
+      await this.withCanonicalState((transition) => this.#loadBlocks(history.slice(prefix.length), transition));
+      if (!checkpoint && !history.length) await this.#machine.updateState(true);
+      const tip = await this.canonicalTip();
+      await globalThis.chainStore.put("lastBlock", tip.hash);
+      await globalThis.chainStore.delete("recoveryTarget");
       this.#loaded = true;
       this.#chainState = "loaded";
     } catch (error) {
-      console.log("e");
-      if (isResolveError(error)) {
-        console.error(error);
-      }
-      console.log(error);
+      this.#loaded = false;
+      this.#chainState = "loading";
+      this.#syncState = "errored";
+      throw error;
     }
   }
   async updateState(message) {
-    try {
-      const hash = await message.hash();
-      await globalThis.chainStore.put("lastBlock", hash);
-      globalThis.pubsub.publish("lastBlock", message.encoded);
-      if (!this.#machine) {
-        const machine = new Machine(this.#blocks);
-        console.log(machine);
-        await machine.ready;
-        this.#machine = machine;
-      }
-      await this.#machine.updateState(true);
-    } catch (error) {
-      console.error(error);
-      throw error;
-    }
+    if (!this.#machine) throw new Error("Cannot checkpoint an uninitialized state machine");
+    const hash = await message.hash();
+    const tip = await this.canonicalTip();
+    if (tip.hash !== hash || Number(tip.index) !== Number(message.decoded.index))
+      throw new Error("Checkpoint target does not match canonical worker tip");
+    await this.#machine.updateState(true);
+    await globalThis.chainStore.put("lastBlock", hash);
+    if (await globalThis.chainStore.has("recoveryTarget") && new TextDecoder().decode(await globalThis.chainStore.get("recoveryTarget")) === hash)
+      await globalThis.chainStore.delete("recoveryTarget");
+    publishObserverEvent(globalThis.pubsub, "lastBlock", message.encoded);
   }
   getLatestBlock() {
     return this.#getLatestBlock();
@@ -4591,7 +5178,7 @@ class State extends Contract {
         this.#blocks[index] = { hash, ...block.decoded };
         this.#blockHashMap.set(hash, index);
         debug$1(`resolved block: ${hash} @${index} ${formatBytes(size)}`);
-        globalThis.pubsub.publish("block-resolved", { hash, index });
+        publishObserverEvent(globalThis.pubsub, "block-resolved", { hash, index });
         this.#lastResolved = this.#blocks[index];
         this.#lastResolvedTime = Date.now();
         hash = block.decoded.previousHash;
@@ -4728,7 +5315,7 @@ class State extends Contract {
       const localIndex = localBlock ? Number(localBlock.index) : -1;
       const remoteIndex = Number(lastBlock.index);
       const remoteBlockHash = lastBlock.hash;
-      globalThis.pubsub.publish("sync-progress", {
+      publishObserverEvent(globalThis.pubsub, "sync-progress", {
         phase: "syncing",
         startIndex: localIndex,
         localIndex,
@@ -4764,6 +5351,7 @@ class State extends Contract {
       if (localStateHash !== remoteBlockHash) {
         debug$1(`Resolving remote block: ${remoteBlockHash} @${remoteIndex} (differs from local state)`);
         await this.resolveBlock(remoteBlockHash);
+        await globalThis.chainStore.put("recoveryTarget", remoteBlockHash);
         const blocksSynced = remoteIndex - localIndex;
         debug$1(`Resolved ${blocksSynced} new block(s)`);
         const blocks = this.#blocks;
@@ -4783,7 +5371,7 @@ class State extends Contract {
       } else {
         debug$1(`Block already in local state. Remote hash: ${remoteBlockHash} matches local state`);
       }
-      globalThis.pubsub.publish("sync-progress", {
+      publishObserverEvent(globalThis.pubsub, "sync-progress", {
         phase: "synced",
         startIndex: localIndex,
         localIndex: remoteIndex,
@@ -4871,112 +5459,23 @@ class State extends Contract {
     }
     return latest;
   }
-  #loadBlockTransactions;
-  #getLastTransactions;
-  // todo throw error
-  async #_executeTransaction(transaction, validators, feesEnabled, burnBasisPoints, blockTimestamp) {
-    try {
-      const hash = await transaction.hash();
-      if (feesEnabled) {
-        const fee = BigInt(await calculateFee(transaction.decoded));
-        const { payments, burned } = distributeTransactionFee(fee, hash, validators, burnBasisPoints);
-        await this.#machine.collectFee(transaction.decoded.from, payments, burned);
-      }
-      await this.#machine.execute(
-        transaction.decoded.to,
-        transaction.decoded.method,
-        transaction.decoded.params,
-        transaction.decoded.from,
-        { seed: hash, timestamp: Number(blockTimestamp) }
-      );
-    } catch (error) {
-      console.log(error);
-      await globalThis.transactionPoolStore.delete(await transaction.hash());
-      console.log("removing invalid transaction");
-      if (isExecutionError(error)) {
-        console.log(error);
-      }
-      console.log(error);
-      throw error;
-    }
+  async applyRecoveredBlock(block, transition) {
+    throw new Error("Canonical block application is not implemented");
   }
-  /**
-   *
-   * @param {Block[]} blocks
-   */
   async #loadBlocks(blocks, transition) {
     this.#chainState = "loading";
-    if (blocks.some((block) => !block)) {
-      throw new Error("missing block data during load; chain resolution incomplete");
-    }
-    const poolTransactionKeys = new Set(await globalThis.transactionPoolStore.keys());
-    debug$1(`pool transactions: ${poolTransactionKeys.size}`);
-    debug$1(`loading ${blocks.length} blocks`);
     for (const block of blocks) {
-      if (block && !block.loaded) {
-        try {
-          const link = validateChainLink(await this.canonicalTip(), {
-            index: Number(block.index),
-            hash: block.hash,
-            previousHash: String(block.previousHash)
-          });
-          if (link !== "append") {
-            this.#blocks[block.index].loaded = true;
-            debug$1(`Ignoring ${link} loaded block ${block.hash} at height ${block.index}`);
-            continue;
-          }
-          debug$1(`loading block: ${Number(block.index)} ${block.hash}`);
-          let transactions = await this.#loadBlockTransactions(block.transactions || []);
-          const validators = block.validators.map(({ address }) => address);
-          debug$1(`loading transactions: ${transactions.length} for block ${block.index}`);
-          transition.markMutating();
-          for (const transaction of transactions) {
-            const hash = await transaction.hash();
-            if (poolTransactionKeys.has(hash)) await globalThis.transactionPoolStore.delete(hash);
-          }
-          transactions = transactions.sort((a, b) => {
-            if (a.decoded.priority !== b.decoded.priority) return a.decoded.priority ? -1 : 1;
-            const left = BigInt(a.decoded.nonce);
-            const right = BigInt(b.decoded.nonce);
-            return left < right ? -1 : left > right ? 1 : 0;
-          });
-          debug$1(`executing ${transactions.length} transactions for block ${block.index}`);
-          const feesEnabled = supportsTransactionFees(block.protocolVersion);
-          const monetaryPolicyEnabled = supportsMonetaryPolicy(block.protocolVersion);
-          if (monetaryPolicyEnabled) await validateBlockResourceLimits(transactions);
-          const policy = monetaryPolicyEnabled ? calculateMonetaryPolicy(
-            BigInt(await this.#machine.get(nativeToken, "totalSupply")),
-            BigInt(await this.#machine.get(nativeToken, "targetSupply"))
-          ) : { subsidy: 0n, burnBasisPoints: 1000n };
-          for (const transaction of transactions) {
-            await this.#_executeTransaction(
-              transaction,
-              validators,
-              feesEnabled,
-              policy.burnBasisPoints,
-              block.timestamp
-            );
-          }
-          if (monetaryPolicyEnabled && policy.subsidy > 0n) {
-            await this.#machine.settleRewards([
-              ...distributeAmount(policy.subsidy, validators, Number(block.index) % validators.length)
-            ]);
-          }
-          debug$1(`executed transactions for block ${block.index}`);
-          const registered = await this.#machine.addLoadedBlock({ ...block, loaded: true });
-          if (registered !== true) throw new Error(`Loaded block registration failed after execution: ${block.hash}`);
-          this.#blocks[block.index].loaded = true;
-          if (Number(block.index) === 0) this.#loaded = true;
-          debug$1(`loaded block: ${block.hash} @${Number(block.index)}`);
-          globalThis.pubsub.publish("block-loaded", { ...block });
-        } catch (error) {
-          console.error(error);
-          for (const transaction of block.transactions) {
-            this.wantList.push(transaction);
-          }
-          throw error;
-        }
-      }
+      if (!block) throw new Error("Missing block data during recovery");
+      if (block.loaded) continue;
+      const { hash, loaded, ...header } = block;
+      const message = new BlockMessage(header);
+      if (await message.hash() !== block.hash) throw new Error("Recovery block hash changed before application");
+      await this.applyRecoveredBlock(message, transition);
+      const tip = await this.canonicalTip();
+      if (tip.hash !== block.hash || Number(tip.index) !== Number(block.index))
+        throw new Error("Recovery did not apply the expected canonical block");
+      block.loaded = true;
+      publishObserverEvent(globalThis.pubsub, "block-loaded", { ...block });
     }
     this.#chainState = "loaded";
     return true;
@@ -5036,18 +5535,16 @@ class State extends Contract {
     return this.syncChain(latest);
   }
   async triggerLoad() {
-    if (this.#blocks?.length > 0) {
-      const machine = new Machine(this.#blocks);
-      console.log(machine);
-      await machine.ready;
-      this.#machine = machine;
-    }
+    if (!this.#machine) throw new Error("Restart the node to initialize recovery");
+    const tip = await this.canonicalTip();
+    return this.withCanonicalState((transition) => this.#loadBlocks(this.#blocks.slice(Number(tip.index) + 1), transition));
   }
 }
 
 class VersionControl extends State {
   constructor(config) {
     super(config);
+    this.version = PROTOCOL_VERSION;
   }
   #currentVersion = PROTOCOL_VERSION;
   #reachedOneZeroZero = REACHED_ONE_ZERO_ZERO;
@@ -5191,80 +5688,13 @@ const assertHashFormatState = async (chainStore, stateStore) => {
     const parsed = /^(\d+)\.(\d+)\.\d+$/.exec(version);
     const current = PROTOCOL_VERSION.split(".");
     if (parsed && parsed[1] === current[0] && parsed[2] === current[1]) return;
-    throw new Error(`stored protocol ${version} is incompatible with canonical hash protocol ${PROTOCOL_VERSION}; back up existing data and use a separate migrated data root`);
+    throw new Error(`stored protocol ${version} is incompatible with canonical hash protocol ${PROTOCOL_VERSION}; explicit ledger migration or a testnet reset is required (preserve the wallet identity)`);
   }
-  if (await chainStore.has("lastBlock") || await stateStore?.has("lastBlock")) {
+  if (await chainStore.has("lastBlock") || await chainStore.has("recoveryTarget") || await stateStore?.has("lastBlock") || await stateStore?.has("checkpoint:0") || await stateStore?.has("checkpoint:1")) {
     throw new Error("existing chainstate has no protocol version; explicit canonical hash migration required");
   }
 };
 
-const CHAIN_ID_SCHEMA = "leofcoin:chain-identity:v1";
-const GENESIS_CONTRACT_NAMES = ["contractFactory", "nativeToken", "nameService", "validators"];
-const assertChainId = (value) => {
-  if (typeof value !== "string" || !/^lfc:[0-9a-f]{64}$/.test(value))
-    throw new Error("Invalid chain ID; expected lfc: followed by 64 lowercase hex characters");
-  return value;
-};
-const createChainIdentity = async (network, contracts) => {
-  if (typeof network !== "string" || !/^[a-z0-9][a-z0-9:-]{0,79}$/.test(network))
-    throw new Error("Invalid genesis network namespace");
-  const genesisContracts = {};
-  for (const name of GENESIS_CONTRACT_NAMES) {
-    const hash = contracts?.[name];
-    if (typeof hash !== "string" || !/^[A-Z2-7]{32,128}$/.test(hash))
-      throw new Error(`Invalid genesis contract hash: ${name}`);
-    genesisContracts[name] = hash;
-  }
-  const bytes = new TextEncoder().encode(JSON.stringify({ schema: CHAIN_ID_SCHEMA, network, genesisContracts }));
-  const digest = await globalThis.crypto.subtle.digest("SHA-256", bytes);
-  const chainId = "lfc:" + [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, "0")).join("");
-  return { schema: CHAIN_ID_SCHEMA, chainId, network, genesisContracts };
-};
-const verifyChainIdentity = async (value) => {
-  const identity = value;
-  if (!identity || identity.schema !== CHAIN_ID_SCHEMA)
-    throw new Error("Unsupported chain identity response");
-  const verified = await createChainIdentity(identity.network, identity.genesisContracts);
-  if (verified.chainId !== assertChainId(identity.chainId))
-    throw new Error("Chain ID does not match its genesis contracts");
-  return verified;
-};
-const findChainPresence = async (chainId, peerIds, requestIdentity, timeoutMs = 3e3) => {
-  assertChainId(chainId);
-  const peers = [...new Set(peerIds)].slice(0, 16);
-  const matches = [];
-  let responded = 0;
-  let unavailable = 0;
-  await Promise.all(peers.map(async (peerId) => {
-    let timer;
-    try {
-      const result = await Promise.race([
-        Promise.resolve().then(() => requestIdentity(peerId)),
-        new Promise((_, reject) => {
-          timer = setTimeout(() => reject(new Error("Chain identity request timed out")), timeoutMs);
-        })
-      ]);
-      const identity = await verifyChainIdentity(result);
-      responded++;
-      if (identity.chainId === chainId)
-        matches.push(peerId);
-    } catch {
-      unavailable++;
-    } finally {
-      clearTimeout(timer);
-    }
-  }));
-  return {
-    chainId,
-    status: matches.length ? "found" : !peers.length || unavailable ? "unknown" : "not-observed",
-    checkedPeers: peers.length,
-    respondedPeers: responded,
-    unavailablePeers: unavailable,
-    matchingPeers: matches.sort(),
-    scope: "reachable peers only; offline or undiscovered chains may still exist"
-  };
-};
-
 const debug = createDebugger("leofcoin/chain");
 class Chain extends VersionControl {
   constructor(config) {
@@ -5864,10 +6294,10 @@ class Chain extends VersionControl {
       });
     });
     globalThis.peernet.subscribe("add-block", this.#addBlock.bind(this));
-    globalThis.peernet.subscribe("invalid-transaction", this.#invalidTransaction.bind(this));
+    globalThis.peernet.subscribe("invalid-transaction", (bytes) => this.#invalidTransaction(decodeWire$1("invalid-transaction", bytes)));
     globalThis.peernet.subscribe("send-transaction", this.#sendTransaction.bind(this));
     globalThis.peernet.subscribe("add-transaction", this.#addTransaction.bind(this));
-    globalThis.peernet.subscribe("validator:timeout", this.#validatorTimeout.bind(this));
+    globalThis.peernet.subscribe("validator:timeout", (bytes) => this.#validatorTimeout(decodeWire$1("validator:timeout", bytes)));
     globalThis.peernet.subscribe("consensus:propose", this.#handleProposal.bind(this));
     globalThis.peernet.subscribe("consensus:prevote", this.#handlePrevote.bind(this));
     globalThis.peernet.subscribe("consensus:precommit", this.#handlePrecommit.bind(this));
@@ -5913,52 +6343,7 @@ class Chain extends VersionControl {
       let response = await peer.request(node.encoded);
       console.log(`raw response for request ${request}:`, response);
       if (response === void 0 || response === null) return response;
-      const normalizeResponse = async (payload) => {
-        if (payload === void 0 || payload === null) return payload;
-        if (payload instanceof Uint8Array || typeof Buffer !== "undefined" && Buffer.isBuffer(payload)) {
-          let bytes = payload instanceof Uint8Array ? payload : new Uint8Array(payload);
-          for (let i = 0; i < 3; i += 1) {
-            try {
-              const codec = new Codec(bytes);
-              if (codec.name !== "peernet-response") break;
-              const wrapped = await new globalThis.peernet.protos["peernet-response"](bytes);
-              if (wrapped?.decoded?.response === void 0) break;
-              const next = wrapped.decoded.response;
-              if (next instanceof Uint8Array || typeof Buffer !== "undefined" && Buffer.isBuffer(next)) {
-                bytes = next instanceof Uint8Array ? next : new Uint8Array(next);
-                continue;
-              }
-              return normalizeResponse(next);
-            } catch {
-              break;
-            }
-          }
-          try {
-            return JSON.parse(new TextDecoder().decode(bytes));
-          } catch {
-            return bytes;
-          }
-        }
-        if (payload && typeof payload === "object") {
-          const objectPayload = payload;
-          const decoded = objectPayload.decoded;
-          if ("decoded" in objectPayload && decoded && "response" in decoded) {
-            return normalizeResponse(decoded.response);
-          }
-          if ("response" in objectPayload) {
-            return normalizeResponse(objectPayload.response);
-          }
-        }
-        if (typeof payload === "string") {
-          try {
-            return JSON.parse(payload);
-          } catch {
-            return payload;
-          }
-        }
-        return payload;
-      };
-      return await normalizeResponse(response);
+      return decodeResponsePayload(response);
     } catch (error) {
       const peerId = peer?.peerId || peer?.id || peer?.address || "unknown";
       debug(`peernet request failed: ${request} -> ${peerId}:`, error?.message ?? error);
@@ -5966,60 +6351,11 @@ class Chain extends VersionControl {
     }
   }
   async #decodeKnownBlocksResponse(response) {
-    if (!response) return null;
-    if (Array.isArray(response)) {
-      return { blocks: response };
-    }
-    if (Array.isArray(response.blocks)) {
-      return { blocks: response.blocks };
-    }
-    if (response.response && Array.isArray(response.response.blocks)) {
-      return { blocks: response.response.blocks };
-    }
-    if (typeof response === "string") {
-      try {
-        const parsed = JSON.parse(response);
-        if (Array.isArray(parsed)) return { blocks: parsed };
-        if (parsed && Array.isArray(parsed.blocks)) return { blocks: parsed.blocks };
-        if (parsed?.response && Array.isArray(parsed.response.blocks)) return { blocks: parsed.response.blocks };
-      } catch {
-        return null;
-      }
-      return null;
-    }
-    if (!(response instanceof Uint8Array)) return null;
-    let payload = response;
-    for (let i = 0; i < 3; i++) {
-      if (!(payload instanceof Uint8Array)) break;
-      try {
-        const nestedResponse = await new globalThis.peernet.protos["peernet-response"](payload);
-        payload = nestedResponse?.decoded?.response;
-      } catch {
-        break;
-      }
-    }
-    if (Array.isArray(payload)) return { blocks: payload };
-    if (payload && Array.isArray(payload.blocks)) return { blocks: payload.blocks };
-    if (payload?.response && Array.isArray(payload.response.blocks)) return { blocks: payload.response.blocks };
-    try {
-      const decoded = new TextDecoder().decode(response);
-      const parsed = JSON.parse(decoded);
-      if (Array.isArray(parsed)) return { blocks: parsed };
-      if (parsed && Array.isArray(parsed.blocks)) return { blocks: parsed.blocks };
-      if (parsed?.response && Array.isArray(parsed.response.blocks)) return { blocks: parsed.response.blocks };
-    } catch {
-      return null;
-    }
-    return null;
+    if (!Array.isArray(response) || response.length > 1e5 || response.some((hash) => typeof hash !== "string")) return null;
+    return { blocks: response };
   }
   async getPeerTransactionPool(peer) {
     let transactionsInPool = await this.#makeRequest(peer, "transactionPool");
-    if (transactionsInPool instanceof Uint8Array) {
-      transactionsInPool = new TextDecoder().decode(transactionsInPool);
-    }
-    if (typeof transactionsInPool === "string") {
-      transactionsInPool = JSON.parse(transactionsInPool);
-    }
     if (!Array.isArray(transactionsInPool) || transactionsInPool.some((hash) => typeof hash !== "string")) {
       throw new Error("transactionPool response must be an array of transaction hashes");
     }
@@ -6157,7 +6493,6 @@ class Chain extends VersionControl {
       debug(
         `sync finished with peer ${peerId}: state=${this.syncState} localNow=${(await this.lastBlock)?.index ?? -1}`
       );
-      this.machine.states.info = stateInfo;
     } catch (error) {
       const peerName = peer?.peerId || peer?.id || peer?.address || peerId || "unknown";
       debug(`stateInfo/syncChain failed: ${peerName}:`, error?.message ?? error);
@@ -6195,7 +6530,7 @@ class Chain extends VersionControl {
     } catch (error) {
       await transactionPoolStore.delete(hash);
       try {
-        globalThis.peernet.publish("invalid-transaction", hash);
+        globalThis.peernet.publish("invalid-transaction", encodeWire$1("invalid-transaction", hash));
       } catch (publishError) {
         debug("peernet publish failed: invalid-transaction", publishError?.message ?? publishError);
       }
@@ -6206,7 +6541,13 @@ class Chain extends VersionControl {
   async #addBlock(block) {
     return this.withCanonicalState((transition) => this.#applyBlock(block, transition));
   }
-  async #applyBlock(block, transition) {
+  applyRecoveredBlock(block, transition) {
+    return this.#applyBlock(block, transition, false);
+  }
+  #recordValidatorSnapshot(index) {
+    return this.machine.execute(addresses.validators, "recordValidatorSnapshot", [index], globalThis.peernet.selectedAccount);
+  }
+  async #applyBlock(block, transition, schedule = true) {
     const receivedEncoded = block instanceof BlockMessage ? block.encoded : block;
     const blockMessage = await new BlockMessage(block);
     const hash = await blockMessage.hash();
@@ -6240,13 +6581,14 @@ class Chain extends VersionControl {
     console.log(`[chain] \u2705 Block data integrity verified: ${hash}`);
     await this.#validateBlockValidators(blockMessage);
     const transactions = await this.#resolveBlockTransactions(blockMessage);
+    await globalThis.blockStore.put(hash, blockMessage.encoded);
+    if (!await globalThis.chainStore.has("recoveryTarget")) await globalThis.chainStore.put("recoveryTarget", hash);
     transition.markMutating();
     await Promise.all(
       blockMessage.decoded.transactions.map(async (transactionHash) => {
         if (await transactionPoolStore.has(transactionHash)) await transactionPoolStore.delete(transactionHash);
       })
     );
-    await globalThis.blockStore.put(hash, blockMessage.encoded);
     this.#blocks[blockIndex] = {
       hash,
       ...blockMessage.decoded
@@ -6280,9 +6622,6 @@ class Chain extends VersionControl {
     }
     const noncesByAddress = {};
     for (let transaction of transactions) {
-      globalThis.pubsub.publish("transaction-processed", transaction.encoded);
-      if (transaction.decoded.to === globalThis.peernet.selectedAccount)
-        globalThis.pubsub.publish("account-transaction-processed", transaction.encoded);
       if (!noncesByAddress[transaction.decoded.from] || noncesByAddress?.[transaction.decoded.from] < transaction.decoded.nonce) {
         noncesByAddress[transaction.decoded.from] = transaction.decoded.nonce;
       }
@@ -6300,14 +6639,19 @@ class Chain extends VersionControl {
     const registered = await this.machine.addLoadedBlock({ ...blockMessage.decoded, loaded: true, hash });
     if (registered !== true) throw new Error(`Block registration failed after execution: ${hash}`);
     try {
-      await this.call(addresses.validators, "recordValidatorSnapshot", [blockMessage.decoded.index]);
+      await this.#recordValidatorSnapshot(blockMessage.decoded.index);
     } catch (snapshotError) {
       debug(`failed to record validator snapshot: ${snapshotError?.message ?? snapshotError}`);
     }
     await this.updateState(blockMessage);
     debug(`added block: ${hash}`);
-    globalThis.pubsub.publish("block-processed", blockMessage.decoded);
-    await this.#handleEpochBoundary(blockIndex);
+    for (const transaction of transactions) {
+      publishObserverEvent(globalThis.pubsub, "transaction-processed", transaction.encoded);
+      if (transaction.decoded.to === globalThis.peernet.selectedAccount)
+        publishObserverEvent(globalThis.pubsub, "account-transaction-processed", transaction.encoded);
+    }
+    publishObserverEvent(globalThis.pubsub, "block-processed", blockMessage.decoded);
+    if (schedule) await this.#handleEpochBoundary(blockIndex);
   }
   async participate(address) {
     try {
@@ -6355,15 +6699,14 @@ class Chain extends VersionControl {
   async #handleTransaction(transaction, latestTransactions, block, feePayments = { payments: [], burned: 0n }) {
     await this.validateTransactionSignature(transaction);
     const hash = await transaction.hash();
-    const doubleTransactions = [];
-    if (latestTransactions.includes(hash) || await transactionStore.has(hash)) {
-      doubleTransactions.push(hash);
-    }
-    if (doubleTransactions.length > 0) {
-      await globalThis.transactionPoolStore.delete(hash);
-      await globalThis.peernet.publish("invalid-transaction", hash);
-      return;
-    }
+    if (latestTransactions.includes(hash)) throw new Error(`Duplicate canonical transaction: ${hash}`);
+    const nonce = BigInt(transaction.decoded.nonce);
+    let committed = 0n;
+    if (await globalThis.accountsStore.has(transaction.decoded.from)) {
+      const raw = await globalThis.accountsStore.get(transaction.decoded.from);
+      committed = BigInt(typeof raw === "string" ? raw : new TextDecoder().decode(raw));
+    }
+    if (nonce <= committed) throw new Error(`Transaction nonce already committed: ${hash}`);
     try {
       const result = await this.#executeTransaction({
         ...transaction.decoded,
@@ -6380,7 +6723,7 @@ class Chain extends VersionControl {
       console.log("vvvvvv");
       console.log({ e });
       console.log(hash);
-      peernet.publish("invalid-transaction", hash);
+      peernet.publish("invalid-transaction", encodeWire$1("invalid-transaction", hash));
       await globalThis.transactionPoolStore.delete(e.hash);
       if (block) throw e;
     }
@@ -6545,7 +6888,7 @@ class Chain extends VersionControl {
     } catch (e) {
       if (hash) {
         try {
-          await globalThis.peernet.publish("invalid-transaction", hash);
+          await globalThis.peernet.publish("invalid-transaction", encodeWire$1("invalid-transaction", hash));
         } catch (publishError) {
           debug("peernet publish failed: invalid-transaction", publishError?.message ?? publishError);
         }
@@ -6559,7 +6902,8 @@ class Chain extends VersionControl {
    * error is thrown on error so undefined data doesn't mean there is an error...
    **/
   async sendTransaction(transaction) {
-    const transactionMessage = await new TransactionMessage({ ...transaction });
+    const { hash: ignoredHash, ...payload } = transaction instanceof TransactionMessage ? transaction.decoded : transaction;
+    const transactionMessage = await new TransactionMessage(payload);
     const event = await super.sendTransaction(transactionMessage);
     await this.#sendTransaction(transactionMessage.encoded);
     try {
@@ -6599,7 +6943,7 @@ class Chain extends VersionControl {
    * @returns
    */
   internalCall(sender, contract, method, parameters) {
-    return this.machine.execute(contract, method, parameters, sender);
+    throw new Error("Direct sender impersonation is disabled; submit a signed transaction with sendTransaction()");
   }
   /**
    *
@@ -6608,18 +6952,23 @@ class Chain extends VersionControl {
    * @param {Array} parameters
    * @returns
    */
-  call(contract, method, parameters) {
-    return this.machine.execute(contract, method, parameters, globalThis.peernet.selectedAccount);
+  async call(transaction, ...legacy) {
+    const signed = transaction instanceof TransactionMessage ? transaction.decoded : transaction;
+    if (legacy.length || !signed || typeof signed !== "object" || typeof signed.signature !== "string" || !signed.signature)
+      throw new Error("call() requires a signed transaction object; use staticCall() for reads or sendTransaction() for writes");
+    return this.sendTransaction(structuredClone(signed));
   }
   staticCall(contract, method, parameters) {
     return this.machine.get(contract, method, parameters);
   }
-  mint(to, amount) {
-    return this.call(addresses.nativeToken, "mint", [to, amount]);
+  mint(...args) {
+    throw new Error("Native minting is restricted to the monetary protocol");
   }
-  transfer(from, to, amount) {
-    if (from !== globalThis.peernet.selectedAccount) throw new Error("transfer sender must be the selected account");
-    return this.call(addresses.nativeToken, "transfer", [to, amount]);
+  async transfer(transaction, ...legacy) {
+    const signed = transaction instanceof TransactionMessage ? transaction.decoded : transaction;
+    if (legacy.length || signed?.to !== addresses.nativeToken || signed?.method !== "transfer")
+      throw new Error("transfer() requires a signed native-token transfer transaction");
+    return this.call(signed);
   }
   balanceOf(address) {
     return this.staticCall(addresses.nativeToken, "balanceOf", [address]);
@@ -6646,7 +6995,7 @@ class Chain extends VersionControl {
    * @example chain.lookup('myCoolContractName') // qmqsfddfdgfg...
    */
   lookup(name) {
-    return this.call(addresses.nameService, "lookup", [name]);
+    return this.staticCall(addresses.nameService, "lookup", [name]);
   }
   #monitorPeerConnections() {
     setInterval(() => {