@leofcoin/chain 1.10.21 → 1.11.0

package/exports/chain.js

@@ -1,65 +1,74 @@
-import { createDebugger } from '@vandeurenglenn/debug';
+import { decodeWire, encodeWire } from '@leofcoin/binary';
 import { Codec } from '@leofcoin/codec-format-interface';
-import { jsonStringifyBigInt, jsonParseBigInt, formatBytes, parseUnits, formatUnits } from '@leofcoin/utils';
-import { TransactionMessage, BlockMessage, ContractMessage, LastBlockMessage, PrevoteMessage, PrecommitMessage, ProposalMessage, BWMessage, StateMessage } from '@leofcoin/messages';
-import addresses, { contractFactory, nativeToken } from '@leofcoin/addresses';
-import { MAX_TRANSACTION_BYTES, MAX_BLOCK_TRANSACTION_BYTES, MAX_BLOCK_TRANSACTIONS, createTransactionHash, calculateFee, createContractMessage, signTransaction, distributeTransactionFee, supportsTransactionFees, supportsMonetaryPolicy, validateBlockResourceLimits, calculateMonetaryPolicy, distributeAmount, aggregateValidatorFees, MONETARY_POLICY_AUTHORITY, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage } from '@leofcoin/lib';
+import { createDebugger } from '@vandeurenglenn/debug';
+import { formatBytes, parseUnits, formatUnits } from '@leofcoin/utils';
+import { TransactionMessage, BlockMessage, LastBlockMessage, PrevoteMessage, PrecommitMessage, ProposalMessage, ContractMessage, BWMessage, StateMessage } from '@leofcoin/messages';
+import addresses from '@leofcoin/addresses';
+import { MAX_TRANSACTION_BYTES, MAX_BLOCK_TRANSACTION_BYTES, MAX_BLOCK_TRANSACTIONS, createTransactionHash, calculateFee, createContractMessage, signTransaction, supportsTransactionFees, supportsMonetaryPolicy, validateBlockResourceLimits, aggregateValidatorFees, distributeAmount, MONETARY_POLICY_AUTHORITY, calculateMonetaryPolicy, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage, distributeTransactionFee } from '@leofcoin/lib';
 import MultiWallet from '@leofcoin/multi-wallet';
 import { fromBase58 } from '@vandeurenglenn/typed-array-utils';
 import semver from 'semver';
-import { randombytes } from '@leofcoin/crypto';
-import EasyWorker from '@vandeurenglenn/easy-worker';
-import { ContractDeploymentError, ExecutionError, isResolveError, ResolveError, isExecutionError } from '@leofcoin/errors';
-import { P as PROTOCOL_VERSION, R as REACHED_ONE_ZERO_ZERO } from './constants-Dy9i9S_o.js';
-import ConnectionMonitor from './connection-monitor.js';
+import { P as Protocol, C as ConnectionMonitor } from './connection-monitor-BdFLRh-J.js';
+import Machine from './machine.js';
+import { createChainIdentity, assertChainId, findChainPresence } from '@leofcoin/lib/chain-identity';
+import { r as readCheckpoint, a as recoveryHistory, b as restoreAccountNonces, v as validateChainLink } from './state-checkpoint-BiQ1EXzo.js';
+import { ResolveError } from '@leofcoin/errors';
+import { P as PROTOCOL_VERSION, R as REACHED_ONE_ZERO_ZERO } from './constants-BQ6f-_OT.js';
 import { q as quorumThreshold } from './quorum-S_qdgiAY.js';
 import { assertHashFormatState } from './hash-format-state.js';
-import { createChainIdentity, assertChainId, findChainPresence } from '@leofcoin/lib/chain-identity';
+import '@leofcoin/crypto';
+import '@leofcoin/workers/binary-worker';
 import '@leofcoin/networks';
 
-const limit = 1800;
-const transactionLimit = 2500;
-const requestTimeout = 3e4;
-const syncTimeout = 3e4;
-class Protocol {
-  constructor(config) {
-    this.resolveTimeout = 1e4;
-    if (config?.resolveTimeout) this.resolveTimeout = config.resolveTimeout;
-  }
-  get limit() {
-    return limit;
-  }
-  get transactionLimit() {
-    return transactionLimit;
-  }
-  get requestTimeout() {
-    return requestTimeout;
-  }
-  get syncTimeout() {
-    return syncTimeout;
-  }
-}
+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 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();
@@ -260,9 +269,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 {
@@ -270,12 +280,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;
     }
   }
@@ -602,511 +616,6 @@ class Contract extends Transaction {
   }
 }
 
-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);
-  }
-  init(blocks) {
-    return this.#init(blocks);
-  }
-  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]);
-        }
-        break;
-      }
-      case "error": {
-        console.error(data.message);
-        break;
-      }
-      case "machine-ready": {
-        this.readyResolve(this);
-        pubsub.publish("machine.ready", true);
-        break;
-      }
-      case "response": {
-        pubsub.publish(data.id, data.value || false);
-        break;
-      }
-      case "addToWantList": {
-        if (!this.wantList.includes(data.hash)) this.wantList.push(data.hash);
-        break;
-      }
-      case "ask": {
-        if (data.question === "contract" || data.question === "transaction") {
-          try {
-            const input = await peernet.get(data.input, data.question);
-            if (input === void 0) {
-              this.worker.postMessage({ id: data.id, error: `could not get ${data.question} @${data.input}` });
-              this.wantList.push(data.input);
-            } else {
-              this.worker.postMessage({ id: data.id, input });
-            }
-          } catch (error) {
-            console.error(error);
-            this.worker.postMessage({ id: data.id, error: `could not get ${data.question} @${data.input}` });
-            this.wantList.push(data.input);
-          }
-        } else if (data.question === "peers") {
-          this.worker.postMessage({
-            id: data.id,
-            input: peernet.connections ? Object.entries(peernet.connections).map(([id, peer]) => peer.toJSON()) : []
-          });
-        } else {
-          this.worker.postMessage({ id: data.id, input: data.input });
-        }
-      }
-    }
-  }
-  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);
-      }
-    } catch (error) {
-      console.error(error);
-      if (strict) 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 #runContract(contractMessage) {
-    const hash = await contractMessage.hash();
-    return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString("hex");
-      const onmessage = (message) => {
-        pubsub.unsubscribe(id, onmessage);
-        if (message?.error) reject(message.error);
-        else resolve(message);
-      };
-      pubsub.subscribe(id, onmessage);
-      this.worker.postMessage({
-        type: "run",
-        id,
-        input: {
-          decoded: contractMessage.decoded,
-          encoded: contractMessage.encoded,
-          hash
-        }
-      });
-    });
-  }
-  /**
-   *
-   * @param {Address} contract
-   * @param {String} method
-   * @param {Array} parameters
-   * @returns Promise<message>
-   */
-  async execute(contract, method, parameters, sender, execution) {
-    try {
-      if (contract === contractFactory && method === "registerContract") {
-        if (await this.has(parameters[0])) throw new Error(`duplicate contract @${parameters[0]}`);
-        let message;
-        if (!await globalThis.contractStore.has(parameters[0])) {
-          message = await peernet.get(parameters[0], "contract");
-          if (!message) throw new Error(`contract ${parameters[0]} not available`);
-          message = await new ContractMessage(message);
-          await globalThis.contractStore.put(await message.hash(), message.encoded);
-        }
-        if (!message) {
-          message = await globalThis.contractStore.get(parameters[0]);
-          message = await new ContractMessage(message);
-        }
-        if (!await this.has(await message.hash())) await this.#runContract(message);
-      }
-    } catch (error) {
-      throw new ContractDeploymentError(`contract deployment failed for ${parameters[0]}
-${error.message}`);
-    }
-    return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString("hex");
-      const timeout = setTimeout(() => {
-        pubsub.unsubscribe(id, onmessage);
-        reject(new Error(`Machine.execute timeout for ${contract}.${method}`));
-      }, 3e4);
-      const onmessage = (message) => {
-        clearTimeout(timeout);
-        pubsub.unsubscribe(id, onmessage);
-        if (message?.error) reject(new ExecutionError(message.error));
-        else resolve(message);
-      };
-      pubsub.subscribe(id, onmessage);
-      this.worker.postMessage({
-        type: "execute",
-        id,
-        input: {
-          to: contract,
-          contract,
-          method,
-          params: parameters,
-          sender,
-          executionSeed: execution?.seed,
-          executionTimestamp: execution?.timestamp,
-          executionRandomness: execution?.randomness
-        }
-      });
-    });
-  }
-  collectFee(from, payments, burned) {
-    return this.#askWorker("collectFee", { from, payments, burned });
-  }
-  settleRewards(rewards) {
-    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
-        }
-      });
-    });
-  }
-  async has(address) {
-    return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString("hex");
-      const timeout = setTimeout(() => {
-        pubsub.unsubscribe(id, onmessage);
-        reject(new Error(`Machine.has timeout for ${address}`));
-      }, 1e4);
-      const onmessage = (message) => {
-        clearTimeout(timeout);
-        pubsub.unsubscribe(id, onmessage);
-        if (message?.error) reject(message.error);
-        else resolve(message);
-      };
-      pubsub.subscribe(id, onmessage);
-      this.worker.postMessage({
-        type: "has",
-        id,
-        input: {
-          address
-        }
-      });
-    });
-  }
-  #askWorker(type, input) {
-    return new Promise((resolve, reject) => {
-      const id = randombytes(20).toString("hex");
-      const timeout = setTimeout(() => {
-        pubsub.unsubscribe(id, onmessage);
-        reject(new Error(`Machine.#askWorker timeout for ${type}`));
-      }, 3e4);
-      const onmessage = (message) => {
-        clearTimeout(timeout);
-        pubsub.unsubscribe(id, onmessage);
-        if (message?.error) reject(message.error);
-        else resolve(message);
-      };
-      pubsub.subscribe(id, onmessage);
-      this.worker.postMessage({
-        type,
-        id,
-        input
-      });
-    });
-  }
-  get contracts() {
-    return this.#askWorker("contracts");
-  }
-  get totalContracts() {
-    return this.#askWorker("totalContracts");
-  }
-  get nativeCalls() {
-    return this.#askWorker("nativeCalls");
-  }
-  get nativeMints() {
-    return this.#askWorker("nativeMints");
-  }
-  get nativeBurns() {
-    return this.#askWorker("nativeBurns");
-  }
-  get nativeTransfers() {
-    return this.#askWorker("nativeTransfers");
-  }
-  get totalBurnAmount() {
-    return this.#askWorker("totalBurnAmount");
-  }
-  get totalMintAmount() {
-    return this.#askWorker("totalMintAmount");
-  }
-  get totalTransferAmount() {
-    return this.#askWorker("totalTransferAmount");
-  }
-  get totalTransactions() {
-    return this.#askWorker("totalTransactions");
-  }
-  get totalBlocks() {
-    return this.#askWorker("totalBlocks");
-  }
-  get blocks() {
-    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;
-    });
-  }
-  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);
-    });
-  }
-  getBlocks(from, to) {
-    return this.#askWorker("blocks", { from, to });
-  }
-  getBlock(index) {
-    return this.#askWorker("block", index);
-  }
-  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));
-  }
-  async latestTransactions() {
-    return this.#askWorker("latestTransactions");
-  }
-  async delete(hash) {
-    return globalThis.contractStore.delete(hash);
-  }
-  /**
-   *
-   * @returns Promise
-   */
-  async deleteAll() {
-    let hashes = await globalThis.contractStore.keys();
-    hashes = Object.keys(hashes).map((hash) => this.delete(hash));
-    return Promise.all(hashes);
-  }
-}
-
 class Jobber {
   constructor(timeout) {
     this.busy = false;
@@ -1136,91 +645,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) {
@@ -1246,27 +683,50 @@ 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}`
-    );
+const resolveTransactionReference = async (expectedHash, transactionData) => {
+  const transaction = transactionData instanceof TransactionMessage ? transactionData : new TransactionMessage(transactionData);
+  const actualHash = await transaction.hash();
+  if (actualHash !== expectedHash) {
+    throw new Error(`Transaction hash mismatch: expected ${expectedHash}, got ${actualHash}`);
   }
-  return "append";
+  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) {
@@ -1283,7 +743,7 @@ class State extends Contract {
     this.#totalSize = 0;
     this.#canonicalStateQueue = new CanonicalStateQueue();
     this.#loaded = false;
-    this.#resolvingHashes = /* @__PURE__ */ new Set();
+    this.#resolvingHashes = /* @__PURE__ */ new Map();
     this._wantList = [];
     this.#chainStateHandler = () => {
       return new globalThis.peernet.protos["peernet-response"]({
@@ -1300,15 +760,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;
@@ -1326,7 +777,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" });
@@ -1426,91 +883,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 };
+      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;
+      }
+      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;
         }
-        console.log("State init after localBlock set");
-      } else {
-        localBlock = { index: 0, hash: "0x0", previousHash: "0x0" };
       }
-    } 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();
-        }
-      } else {
-        await this.resolveBlocks();
+      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;
       }
-      const machine = new Machine(this.#blocks);
-      console.log(machine);
+      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();
@@ -1539,7 +984,8 @@ class State extends Contract {
         if (!exists) {
           const data = await peernet.get(hash, "transaction");
           if (!data) throw new Error(`missing transaction data for ${hash}`);
-          await transactionStore.put(hash, data);
+          const transaction = await resolveTransactionReference(hash, data);
+          await transactionStore.put(hash, transaction.encoded);
         }
         const inPool = await transactionPoolStore.has(hash);
         if (inPool) await transactionPoolStore.delete(hash);
@@ -1547,84 +993,61 @@ class State extends Contract {
     );
   }
   async #resolveBlock(hash) {
-    let index = this.#blockHashMap.get(hash);
-    let localHash = "0x0";
-    try {
-      const rawLocalHash = await globalThis.stateStore.get("lastBlock");
-      if (rawLocalHash) {
-        const decoded = JSON.parse(new TextDecoder().decode(rawLocalHash));
-        localHash = typeof decoded === "string" ? decoded : decoded?.hash ?? "0x0";
+    const localHash = (await this.canonicalTip()).hash;
+    const visited = /* @__PURE__ */ new Set();
+    while (hash !== "0x0" && hash !== localHash) {
+      if (visited.has(hash)) throw new ResolveError(`cyclic block ancestry at ${hash}`);
+      visited.add(hash);
+      const cachedIndex = this.#blockHashMap.get(hash);
+      const cached = this.#blocks[cachedIndex];
+      if (cached) {
+        hash = cached.previousHash;
+        continue;
       }
-    } catch (error) {
-      debug$1("no local state found");
-    }
-    if (this.#blocks[index]) {
-      const previousHash = this.#blocks[index].previousHash;
-      if (previousHash === localHash) return;
-      if (previousHash !== "0x0") {
-        return this.resolveBlock(previousHash);
-      } else {
-        return;
+      try {
+        const block = await this.getAndPutBlock(hash);
+        await this.#resolveTransactions(block.decoded.transactions);
+        const index = block.decoded.index;
+        const size = block.encoded.byteLength;
+        this.#totalSize += size;
+        this.#blocks[index] = { hash, ...block.decoded };
+        this.#blockHashMap.set(hash, index);
+        debug$1(`resolved block: ${hash} @${index} ${formatBytes(size)}`);
+        publishObserverEvent(globalThis.pubsub, "block-resolved", { hash, index });
+        this.#lastResolved = this.#blocks[index];
+        this.#lastResolvedTime = Date.now();
+        hash = block.decoded.previousHash;
+      } catch (error) {
+        throw new ResolveError(`block: ${hash}`, { cause: error });
       }
     }
-    try {
-      const block = await this.getAndPutBlock(hash);
-      const promises = [];
-      if (block.decoded.previousHash !== "0x0" && block.decoded.previousHash !== localHash) {
-        promises.push(this.resolveBlock(block.decoded.previousHash));
-      }
-      promises.push(this.#resolveTransactions(block.decoded.transactions));
-      await Promise.all(promises);
-      index = block.decoded.index;
-      const size = block.encoded.length > 0 ? block.encoded.length : block.encoded.byteLength;
-      this.#totalSize += size;
-      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 });
-      this.#lastResolved = this.#blocks[index];
-      this.#lastResolvedTime = Date.now();
-    } catch (error) {
-      throw new ResolveError(`block: ${hash}@${index}`, { cause: error });
-    }
-    return;
   }
   async resolveBlock(hash) {
     if (!hash) throw new Error(`expected hash, got: ${hash}`);
     if (hash === "0x0") return;
-    if (this.#resolvingHashes.has(hash)) return;
-    this.#resolvingHashes.add(hash);
-    const isEntering = this.#resolvingHashes.size === 1;
+    const existing = this.#resolvingHashes.get(hash);
+    if (existing) return existing;
     this.#resolving = true;
-    try {
-      if (isEntering) {
-        if (this.jobber.busy && this.jobber.destroy) await this.jobber.destroy();
-        await this.jobber.add(() => this.#resolveBlock(hash));
-      } else {
-        await this.#resolveBlock(hash);
-      }
-      try {
-        const lastBlockHash = await globalThis.stateStore.get("lastBlock");
-        if (lastBlockHash === hash) {
+    const resolution = Promise.resolve().then(async () => {
+      for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+          await this.#resolveBlock(hash);
           this.#resolveErrored = false;
           return;
+        } catch (error) {
+          console.error(`block resolution attempt ${attempt + 1} failed for ${hash}`, error);
+          if (attempt === 2) {
+            if (!this.wantList.includes(hash)) this.wantList.push(hash);
+            throw new ResolveError(`block: ${hash}`, { cause: error });
+          }
         }
-      } catch (error) {
       }
-    } catch (error) {
-      console.log({ error });
-      this.#resolveErrorCount += 1;
-      if (this.#resolveErrorCount < 3) {
-        this.#resolvingHashes.delete(hash);
-        return this.resolveBlock(hash);
-      }
-      this.#resolveErrorCount = 0;
-      this.wantList.push(hash);
-      throw new ResolveError(`block: ${hash}`, { cause: error });
-    } finally {
+    }).finally(() => {
       this.#resolvingHashes.delete(hash);
       if (this.#resolvingHashes.size === 0) this.#resolving = false;
-    }
+    });
+    this.#resolvingHashes.set(hash, resolution);
+    return resolution;
   }
   async resolveBlocks() {
     if (this.#chainSyncing || this.#resolving) {
@@ -1727,7 +1150,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,
@@ -1761,26 +1184,9 @@ class State extends Contract {
         return;
       }
       if (localStateHash !== remoteBlockHash) {
-        if (this.wantList.length > 0) {
-          debug$1(`Fetching ${this.wantList.length} blocks before resolving`);
-          const getBatch = async (batch) => {
-            const blocks2 = await Promise.all(
-              batch.map(
-                (hash) => this.getAndPutBlock(hash).catch((e) => {
-                  console.warn(`failed to fetch block ${hash}`, e);
-                })
-              )
-            );
-            const transactions = blocks2.filter((block) => Boolean(block)).flatMap((block) => block.decoded.transactions);
-            return this.#resolveTransactions(transactions);
-          };
-          for (let i = 0; i < this.wantList.length; i += 50) {
-            const batch = this.wantList.slice(i, i + 50);
-            await getBatch(batch);
-          }
-        }
         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;
@@ -1800,7 +1206,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,
@@ -1888,112 +1294,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;
@@ -2053,18 +1370,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;
@@ -2134,15 +1449,6 @@ const validateBlockEconomics = (block, calculatedFees, validatorFees = /* @__PUR
   }
 };
 
-const resolveTransactionReference = async (expectedHash, transactionData) => {
-  const transaction = transactionData instanceof TransactionMessage ? transactionData : new TransactionMessage(transactionData);
-  const actualHash = await transaction.hash();
-  if (actualHash !== expectedHash) {
-    throw new Error(`Transaction hash mismatch: expected ${expectedHash}, got ${actualHash}`);
-  }
-  return transaction;
-};
-
 const consensusSignableData = (validatorsAddress, type, message) => ({
   from: String(message.from),
   to: validatorsAddress,
@@ -2810,10 +2116,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("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("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));
@@ -2859,52 +2165,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);
@@ -2912,60 +2173,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");
     }
@@ -3090,13 +2302,6 @@ class Chain extends VersionControl {
         }
       }
     }
-    if (this.wantList.length > 0) {
-      const promises = await Promise.allSettled(this.wantList.map((hash) => peernet.get(hash, "block")));
-      for (let i = promises.length - 1; i >= 0; i -= 1) {
-        if (promises[i].status === "fulfilled") this.wantList.splice(i, 1);
-      }
-      if (this.wantList.length === 0) await this.triggerSync();
-    }
     try {
       let stateInfo = await this.#makeRequest(peer, "stateInfo");
       if (stateInfo instanceof Uint8Array) {
@@ -3110,7 +2315,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);
@@ -3148,7 +2352,7 @@ class Chain extends VersionControl {
     } catch (error) {
       await transactionPoolStore.delete(hash);
       try {
-        globalThis.peernet.publish("invalid-transaction", hash);
+        globalThis.peernet.publish("invalid-transaction", encodeWire("invalid-transaction", hash));
       } catch (publishError) {
         debug("peernet publish failed: invalid-transaction", publishError?.message ?? publishError);
       }
@@ -3159,7 +2363,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();
@@ -3193,13 +2403,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
@@ -3233,9 +2444,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;
       }
@@ -3253,14 +2461,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 {
@@ -3308,15 +2521,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,
@@ -3333,7 +2545,7 @@ class Chain extends VersionControl {
       console.log("vvvvvv");
       console.log({ e });
       console.log(hash);
-      peernet.publish("invalid-transaction", hash);
+      peernet.publish("invalid-transaction", encodeWire("invalid-transaction", hash));
       await globalThis.transactionPoolStore.delete(e.hash);
       if (block) throw e;
     }
@@ -3498,7 +2710,7 @@ class Chain extends VersionControl {
     } catch (e) {
       if (hash) {
         try {
-          await globalThis.peernet.publish("invalid-transaction", hash);
+          await globalThis.peernet.publish("invalid-transaction", encodeWire("invalid-transaction", hash));
         } catch (publishError) {
           debug("peernet publish failed: invalid-transaction", publishError?.message ?? publishError);
         }
@@ -3512,7 +2724,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 {
@@ -3552,7 +2765,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()");
   }
   /**
    *
@@ -3561,18 +2774,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]);
@@ -3599,7 +2817,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(() => {