@leofcoin/chain 1.9.24 → 1.10.1

package/exports/chain.js

@@ -1,14 +1,16 @@
 import { createDebugger } from '@vandeurenglenn/debug';
 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, BWRequestMessage } from '@leofcoin/messages';
+import { TransactionMessage, BlockMessage, ContractMessage, LastBlockMessage, PrevoteMessage, PrecommitMessage, ProposalMessage, BWMessage, StateMessage } from '@leofcoin/messages';
 import addresses, { contractFactory } from '@leofcoin/addresses';
-import { calculateFee, createContractMessage, signTransaction, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage } from '@leofcoin/lib';
+import { createTransactionHash, calculateFee, createContractMessage, signTransaction, contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage } 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-C83ZCYKa.js';
+import { P as PROTOCOL_VERSION, R as REACHED_ONE_ZERO_ZERO } from './constants-D6gWzJZg.js';
 import '@leofcoin/networks';
 
 const limit = 1800;
@@ -51,8 +53,14 @@ class Transaction extends Protocol {
     }
   }
   removePendingNonce(address, nonce) {
-    if (this.#pendingNonces.has(address)) {
-      this.#pendingNonces.get(address).delete(nonce);
+    const nonces = this.#pendingNonces.get(address);
+    if (!nonces) return;
+    nonces.delete(nonce);
+    if (this.#maxPendingNonce.get(address) === nonce) {
+      let max = -1;
+      for (const n of nonces) if (n > max) max = n;
+      if (max === -1) this.#maxPendingNonce.delete(address);
+      else this.#maxPendingNonce.set(address, max);
     }
   }
   getPendingNonces(address) {
@@ -121,19 +129,33 @@ class Transaction extends Protocol {
     transactions = transactions.filter((tx) => tx.decoded.from === address);
     transactions = await this.promiseTransactionsContent(transactions);
     if (this.lastBlock?.hash && transactions.length === 0 && this.lastBlock.hash !== "0x0") {
-      let block;
+      let blockHash = this.lastBlock.hash;
       try {
-        block = await globalThis.peernet.get(this.lastBlock.hash, "block");
-      } catch (error) {
-        block = void 0;
-      }
-      if (block === void 0) return [];
-      block = await new BlockMessage(block);
-      transactions = transactions.filter((tx) => tx.from === address);
-      while (transactions.length === 0 && block.decoded.index !== 0 && block.decoded.previousHash !== "0x0") {
-        block = await globalThis.blockStore.get(block.decoded.previousHash);
-        block = await new BlockMessage(block);
-        transactions = block.decoded.transactions.filter((tx) => tx.from === address);
+        while (blockHash && blockHash !== "0x0" && transactions.length === 0) {
+          let rawBlock;
+          try {
+            rawBlock = await globalThis.blockStore.get(blockHash);
+          } catch {
+            rawBlock = await globalThis.peernet.get(blockHash, "block");
+          }
+          if (!rawBlock) break;
+          const block = await new BlockMessage(rawBlock);
+          const blockTransactions = await Promise.all(
+            block.decoded.transactions.map(async (hash) => {
+              let rawTransaction;
+              try {
+                rawTransaction = await globalThis.transactionStore.get(hash);
+              } catch {
+              }
+              if (!rawTransaction) rawTransaction = await globalThis.peernet.get(hash, "transaction");
+              return rawTransaction ? new TransactionMessage(rawTransaction) : void 0;
+            })
+          );
+          transactions = blockTransactions.filter((transaction) => Boolean(transaction)).filter((transaction) => transaction.decoded.from === address).map((transaction) => transaction.decoded);
+          blockHash = block.decoded.previousHash;
+        }
+      } catch {
+        return 0;
       }
     }
     if (transactions.length === 0) return 0;
@@ -189,6 +211,22 @@ class Transaction extends Protocol {
   async createTransactionMessage(transaction, signature) {
     return new TransactionMessage({ ...transaction, signature });
   }
+  async validateTransactionSignature(message) {
+    if (!this.isTransactionMessage(message)) message = await new TransactionMessage(message);
+    const { from, signature } = message.decoded;
+    if (!from || typeof from !== "string") throw new Error("transaction sender required");
+    if (!signature || typeof signature !== "string") throw new Error("transaction not signed");
+    try {
+      const network = globalThis.peernet?.network || "leofcoin";
+      const verifier = new MultiWallet(network);
+      await verifier.fromAddress(from, null, network);
+      const valid = await verifier.verify(fromBase58(signature), await createTransactionHash(message));
+      if (!valid) throw new Error("signature does not match transaction sender");
+    } catch (error) {
+      if (error?.message === "signature does not match transaction sender") throw error;
+      throw new Error(`invalid transaction signature: ${error?.message ?? error}`);
+    }
+  }
   async createTransaction(transaction) {
     return {
       ...transaction,
@@ -198,8 +236,8 @@ class Transaction extends Protocol {
   }
   async sendTransaction(message) {
     if (!this.isTransactionMessage(message)) message = await new TransactionMessage(message);
-    if (!message.decoded.signature) throw new Error(`transaction not signed`);
     if (message.decoded.nonce === void 0) throw new Error(`nonce required`);
+    await this.validateTransactionSignature(message);
     await this.validateNonce(message.decoded.from, message.decoded.nonce);
     const hash = await message.hash();
     try {
@@ -416,6 +454,7 @@ class ContractRegistry {
    */
   clear() {
     this.baseContracts.clear();
+    this.contractNames.clear();
     this.contractDependencies.clear();
   }
   /**
@@ -503,7 +542,7 @@ class Contract extends Transaction {
    */
   async deployDerivedContract(signer, contract, baseContractIdentifier, constructorParameters = []) {
     if (baseContractIdentifier) {
-      const baseContract = contractRegistry.getBaseContract(baseContractIdentifier);
+      const baseContract = contractRegistry.getBaseContract(baseContractIdentifier) ?? contractRegistry.getBaseContractByHash(baseContractIdentifier);
       if (!baseContract) {
         throw new Error(
           `Base contract '${baseContractIdentifier}' not found. Register it first using registerBaseContract.`
@@ -639,7 +678,8 @@ class Machine {
         break;
       }
       case "addToWantList": {
-        this.wantList.push(data.hash);
+        if (!this.wantList.includes(data.hash)) this.wantList.push(data.hash);
+        break;
       }
       case "ask": {
         if (data.question === "contract" || data.question === "transaction") {
@@ -701,9 +741,11 @@ class Machine {
         try {
           const promises = [];
           for (const address of await accountsStore.keys()) {
-            promises.push(async () => {
-              accounts[address] = await accountsStore.get(address);
-            });
+            promises.push(
+              (async () => {
+                accounts[address] = await accountsStore.get(address);
+              })()
+            );
           }
           await Promise.all(promises);
         } catch (error) {
@@ -712,9 +754,7 @@ class Machine {
             const { from, to, amount, nonce } = transaction.decoded.data;
             if (!accounts[from]) {
               accounts[from] = nonce;
-              promises.push(async () => {
-                await accountsStore.put(from, nonce);
-              });
+              promises.push(accountsStore.put(from, nonce));
             }
           }
           await Promise.all(promises);
@@ -1262,7 +1302,7 @@ class State extends Contract {
   #lastBlockHandler;
   #knownBlocksHandler;
   async init() {
-    console.log("State init start");
+    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);
@@ -1297,7 +1337,7 @@ class State extends Contract {
     console.log("State init middle");
     try {
       console.log("fetching known blocks from blockStore");
-      this.knownBlocks = await blockStore.keys();
+      this.knownBlocks = await globalThis.blockStore.keys();
     } catch (error) {
       console.log("no local known blocks found");
     }
@@ -1322,6 +1362,7 @@ class State extends Contract {
         this.updateState(new BlockMessage(lastBlock));
       }
       this.#loaded = true;
+      this.#chainState = "loaded";
     } catch (error) {
       console.log("e");
       if (isResolveError(error)) {
@@ -1469,6 +1510,13 @@ class State extends Contract {
       console.error(error);
     }
     try {
+      if (!await globalThis.chainStore.has("lastBlock")) {
+        if (this.knownBlocks.length === 0) {
+          this.#syncState = "connectionless";
+          return;
+        }
+        return this.restoreChain();
+      }
       const localBlock = await globalThis.chainStore.get("lastBlock");
       const hash = new TextDecoder().decode(localBlock);
       if (hash && hash !== "0x0") {
@@ -1480,10 +1528,15 @@ class State extends Contract {
       this.#chainSyncing = false;
       this.#syncState = "errored";
       this.#resolveErrored = true;
+      if (globalThis.peernet.peers.length === 0) return;
       return this.restoreChain();
     }
   }
   async restoreChain() {
+    if (globalThis.peernet.peers.length === 0 && this.knownBlocks.length === 0) {
+      this.#syncState = "connectionless";
+      return;
+    }
     try {
       const { hash } = await this.#getLatestBlock();
       await globalThis.chainStore.put("lastBlock", hash);
@@ -1495,6 +1548,10 @@ class State extends Contract {
       this.#resolveErrored = true;
       this.#resolveErrorCount += 1;
       this.#resolving = false;
+      if (this.#resolveErrorCount >= 3) {
+        this.#syncState = "errored";
+        throw new ResolveError("unable to restore chain after 3 attempts", { cause: error });
+      }
       return this.restoreChain();
     }
   }
@@ -1549,17 +1606,17 @@ class State extends Contract {
         return;
       }
       if (localIndex > remoteIndex) {
+        const MAX_REORG_DEPTH = 6;
+        const reorgDepth = localIndex - remoteIndex;
+        if (reorgDepth > MAX_REORG_DEPTH) {
+          console.warn(
+            `[consensus-safety] Peer proposing reorg depth of ${reorgDepth} blocks (limit is ${MAX_REORG_DEPTH}). Rejecting to prevent DoS.`
+          );
+          throw new Error(`Excessive reorg depth: ${reorgDepth} blocks (max ${MAX_REORG_DEPTH})`);
+        }
         debug$1(`Local index ${localIndex} is ahead of remote ${remoteIndex}, skipping sync`);
         return;
       }
-      const MAX_REORG_DEPTH = 6;
-      const reorgDepth = localIndex - remoteIndex;
-      if (reorgDepth > 0 && reorgDepth > MAX_REORG_DEPTH) {
-        console.warn(
-          `[consensus-safety] Peer proposing reorg depth of ${reorgDepth} blocks (limit is ${MAX_REORG_DEPTH}). Rejecting to prevent DoS.`
-        );
-        throw new Error(`Excessive reorg depth: ${reorgDepth} blocks (max ${MAX_REORG_DEPTH})`);
-      }
       if (localStateHash !== remoteBlockHash) {
         if (this.wantList.length > 0) {
           debug$1(`Fetching ${this.wantList.length} blocks before resolving`);
@@ -1657,7 +1714,7 @@ class State extends Contract {
       }))
     );
     let latest = { index: 0, hash: "0x0", previousHash: "0x0" };
-    promises = promises.sort((a, b) => b.index - a.index);
+    promises = promises.sort((a, b) => Number(b.value.index) - Number(a.value.index));
     if (promises.length > 0) latest = promises[0].value;
     debug$1(`Latest block from peers: ${latest.hash} @${latest.index}`);
     if (latest.hash && latest.hash !== "0x0") {
@@ -1673,7 +1730,7 @@ class State extends Contract {
         });
         let node2 = await globalThis.peernet.prepareMessage(data2);
         try {
-          let message2 = await peer.request(node2.encode());
+          let message2 = await peer.request(node2.encoded);
           message2 = await new globalThis.peernet.protos["peernet-response"](message2);
           const MAX_WANTLIST_SIZE = 1e3;
           const incoming = message2.decoded.response.blocks.filter((block) => !this.knownBlocks.includes(block));
@@ -1841,6 +1898,10 @@ class VersionControl extends State {
   async init() {
     super.init && await super.init();
     try {
+      if (!await globalThis.chainStore.has("version")) {
+        await this.#setCurrentVersion();
+        return;
+      }
       const version = await globalThis.chainStore.get("version");
       const storedVersion = new TextDecoder().decode(version);
       console.log(storedVersion, this.#currentVersion);
@@ -2158,6 +2219,60 @@ class ConnectionMonitor {
   }
 }
 
+const quorumThreshold = (validatorCount) => {
+  if (!Number.isSafeInteger(validatorCount) || validatorCount < 1) {
+    throw new Error("validator count must be a positive safe integer");
+  }
+  return Math.floor(2 * validatorCount / 3) + 1;
+};
+
+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 consensusSignableData = (validatorsAddress, type, message) => ({
+  from: String(message.from),
+  to: validatorsAddress,
+  method: `consensus:${type}`,
+  params: [String(message.blockHash), String(message.index), String(message.round)],
+  timestamp: 0
+});
+const signConsensusMessage = async (validatorsAddress, type, message, identity) => {
+  if (!identity) throw new Error(`cannot sign ${type} without a local identity`);
+  const signed = await signTransaction(consensusSignableData(validatorsAddress, type, message), identity);
+  return signed.signature;
+};
+const verifyConsensusMessage = async (validatorsAddress, type, message, network) => {
+  if (typeof message.from !== "string" || typeof message.signature !== "string" || !message.signature) return false;
+  try {
+    const verifier = new MultiWallet(network);
+    await verifier.fromAddress(message.from, null, network);
+    return await verifier.verify(
+      fromBase58(message.signature),
+      await createTransactionHash(consensusSignableData(validatorsAddress, type, message))
+    );
+  } catch {
+    return false;
+  }
+};
+
 const debug = createDebugger("leofcoin/chain");
 class Chain extends VersionControl {
   constructor(config) {
@@ -2189,6 +2304,8 @@ class Chain extends VersionControl {
     // ── Tendermint consensus state ──────────────────────────────────────────────
     /** Current consensus round (increments when proposer is unresponsive) */
     this.#consensusRound = 0;
+    /** Locally proposed block awaiting quorum; prevents duplicate proposals at one height. */
+    this.#proposalInFlight = null;
     /** Timer that advances #consensusRound when the proposer doesn't propose in time */
     this.#roundTimer = null;
     /** prevotes collected per `height:round:blockHash` key */
@@ -2197,6 +2314,8 @@ class Chain extends VersionControl {
     this.#precommits = /* @__PURE__ */ new Map();
     /** Index of the last block that reached 2f+1 precommits */
     this.#committedHeight = -1;
+    /** Heights currently applying to local state; prevents duplicate concurrent commits. */
+    this.#committingHeights = /* @__PURE__ */ new Set();
     /** Prevents casting duplicate prevote/precommit per height:round */
     this.#castedVotes = /* @__PURE__ */ new Set();
     this.ready = new Promise((resolve) => {
@@ -2210,9 +2329,10 @@ class Chain extends VersionControl {
     this.#castVote = async (type, blockHash, index, round) => {
       const voteKey = `${type}:${index}:${round}`;
       if (this.#castedVotes.has(voteKey)) return;
-      this.#castedVotes.add(voteKey);
       const from = peernet.selectedAccount;
-      const voteData = { blockHash, index: BigInt(index), round: BigInt(round), from };
+      const unsignedVote = { blockHash, index: BigInt(index), round: BigInt(round), from };
+      const voteData = { ...unsignedVote, signature: await this.#signConsensusMessage(type, unsignedVote) };
+      this.#castedVotes.add(voteKey);
       const Message = type === "prevote" ? PrevoteMessage : PrecommitMessage;
       const message = new Message(voteData);
       const payload = message.encoded;
@@ -2221,6 +2341,8 @@ class Chain extends VersionControl {
       } catch (e) {
         debug(`peernet publish failed: consensus:${type}`, e?.message ?? e);
       }
+      if (type === "prevote") await this.#handlePrevote(payload);
+      else await this.#handlePrecommit(payload);
     };
     /**
      * Phase 2 — receive a block proposal from the designated proposer.
@@ -2232,6 +2354,10 @@ class Chain extends VersionControl {
         const message = new ProposalMessage(payload);
         const msg = message.decoded;
         const { blockHash, index, round, from } = msg;
+        if (!await this.#verifyConsensusMessage("proposal", msg)) {
+          debug(`[consensus] Ignoring proposal with invalid signature from ${from}`);
+          return;
+        }
         const validators = await this.#getConsensusValidators(Number(index));
         const expectedProposerIdx = Number((index + round) % BigInt(validators.length));
         if (!validators[expectedProposerIdx] || validators[expectedProposerIdx] !== from) {
@@ -2277,6 +2403,10 @@ class Chain extends VersionControl {
         const message = new PrevoteMessage(payload);
         const msg = message.decoded;
         const { blockHash, index, round, from } = msg;
+        if (!await this.#verifyConsensusMessage("prevote", msg)) {
+          debug(`[consensus] Ignoring prevote with invalid signature from ${from}`);
+          return;
+        }
         const validators = await this.#getConsensusValidators(Number(index));
         if (!validators.includes(from)) return;
         const localBlock = await this.lastBlock;
@@ -2285,7 +2415,7 @@ class Chain extends VersionControl {
         const voteKey = `${index}:${round}:${blockHash}`;
         if (!this.#prevotes.has(voteKey)) this.#prevotes.set(voteKey, /* @__PURE__ */ new Set());
         this.#prevotes.get(voteKey).add(from);
-        const threshold = Math.ceil(2 * validators.length / 3);
+        const threshold = quorumThreshold(validators.length);
         const voteCount = this.#prevotes.get(voteKey).size;
         debug(`[consensus] Prevotes ${voteKey}: ${voteCount}/${validators.length} (need ${threshold})`);
         if (voteCount >= threshold && validators.includes(peernet.selectedAccount) && !this.#isJailed(peernet.selectedAccount)) {
@@ -2305,46 +2435,48 @@ class Chain extends VersionControl {
         const message = new PrecommitMessage(payload);
         const msg = message.decoded;
         const { blockHash, index, round, from } = msg;
+        if (!await this.#verifyConsensusMessage("precommit", msg)) {
+          debug(`[consensus] Ignoring precommit with invalid signature from ${from}`);
+          return;
+        }
         const validators = await this.#getConsensusValidators(Number(index));
         if (!validators.includes(from)) return;
         if (index <= BigInt(this.#committedHeight)) return;
         const voteKey = `${index}:${round}:${blockHash}`;
         if (!this.#precommits.has(voteKey)) this.#precommits.set(voteKey, /* @__PURE__ */ new Set());
         this.#precommits.get(voteKey).add(from);
-        const threshold = Math.ceil(2 * validators.length / 3);
+        const threshold = quorumThreshold(validators.length);
         const voteCount = this.#precommits.get(voteKey).size;
         debug(`[consensus] Precommits ${voteKey}: ${voteCount}/${validators.length} (need ${threshold})`);
-        if (voteCount >= threshold && index > BigInt(this.#committedHeight)) {
-          this.#committedHeight = Number(index);
-          this.#consensusRound = 0;
-          for (const key of [...this.#prevotes.keys()]) {
-            if (BigInt(key.split(":")[0]) <= index) this.#prevotes.delete(key);
-          }
-          for (const key of [...this.#precommits.keys()]) {
-            if (BigInt(key.split(":")[0]) <= index) this.#precommits.delete(key);
-          }
-          for (const key of [...this.#castedVotes]) {
-            if (BigInt(key.split(":")[1]) <= index) this.#castedVotes.delete(key);
-          }
-          const currentBlock = await this.lastBlock;
-          const currentIndex = currentBlock?.index !== void 0 ? currentBlock.index : -1n;
-          if (index > currentIndex) {
-            debug(`[consensus] \u2705 Committing block ${blockHash} at height ${index}`);
-            try {
-              const blockData = await globalThis.peernet.get(blockHash, "block");
-              await this.#addBlock(blockData);
-            } catch (e) {
-              debug(`[consensus] Failed to commit block ${blockHash}:`, e?.message);
-            }
-          } else {
-            debug(`[consensus] \u2705 Block ${blockHash} at height ${index} already committed (proposer path)`);
-          }
+        const numericIndex = Number(index);
+        if (voteCount >= threshold && index > BigInt(this.#committedHeight) && !this.#committingHeights.has(numericIndex)) {
+          this.#committingHeights.add(numericIndex);
           try {
+            debug(`[consensus] \u2705 Committing block ${blockHash} at height ${index}`);
             const blockData = await globalThis.peernet.get(blockHash, "block");
+            await this.#addBlock(blockData);
+            this.#committedHeight = numericIndex;
+            this.#consensusRound = 0;
+            if (this.#proposalInFlight?.hash === blockHash) this.#proposalInFlight = null;
+            if (this.#roundTimer) {
+              clearTimeout(this.#roundTimer);
+              this.#roundTimer = null;
+            }
+            for (const key of [...this.#prevotes.keys()]) {
+              if (BigInt(key.split(":")[0]) <= index) this.#prevotes.delete(key);
+            }
+            for (const key of [...this.#precommits.keys()]) {
+              if (BigInt(key.split(":")[0]) <= index) this.#precommits.delete(key);
+            }
+            for (const key of [...this.#castedVotes]) {
+              if (BigInt(key.split(":")[1]) <= index) this.#castedVotes.delete(key);
+            }
             globalThis.peernet.publish("add-block", blockData);
             globalThis.pubsub.publish("add-block", blockData);
           } catch (e) {
-            debug("[consensus] Failed to broadcast committed block:", e?.message);
+            debug(`[consensus] Failed to commit block ${blockHash}:`, e?.message);
+          } finally {
+            this.#committingHeights.delete(numericIndex);
           }
         }
       } catch (e) {
@@ -2379,10 +2511,12 @@ class Chain extends VersionControl {
   #minPeerScore;
   #maxPeerFailures;
   #consensusRound;
+  #proposalInFlight;
   #roundTimer;
   #prevotes;
   #precommits;
   #committedHeight;
+  #committingHeights;
   #castedVotes;
   // ────────────────────────────────────────────────────────────────────────────
   #connectionMonitor;
@@ -2422,6 +2556,18 @@ class Chain extends VersionControl {
   #isJailed(address) {
     return typeof address === "string" && this.#jail.has(address);
   }
+  async #signConsensusMessage(type, message) {
+    const identity = globalThis.peernet?.identity;
+    return signConsensusMessage(addresses.validators, type, message, identity);
+  }
+  async #verifyConsensusMessage(type, message) {
+    return verifyConsensusMessage(
+      addresses.validators,
+      type,
+      message,
+      globalThis.peernet?.network || "leofcoin"
+    );
+  }
   async #getConsensusValidators(nextBlockIndex) {
     const localBlock = await this.lastBlock;
     const localIndex = localBlock?.index !== void 0 ? Number(localBlock.index) : -1;
@@ -2435,7 +2581,7 @@ class Chain extends VersionControl {
     const validators = await this.staticCall(addresses.validators, "validators");
     return [...new Set(validators)].sort();
   }
-  #validateBlockValidators(blockMessage) {
+  async #validateBlockValidators(blockMessage) {
     const validators = blockMessage.decoded.validators || [];
     if (!Array.isArray(validators) || validators.length === 0) {
       throw new Error(`Block ${blockMessage.decoded.index} does not include validators`);
@@ -2460,15 +2606,31 @@ class Chain extends VersionControl {
         `Block ${blockMessage.decoded.index} producer ${blockMessage.decoded.producer} is not in validators list`
       );
     }
-    const addresses2 = validators.map((validator) => validator.address);
-    if (addresses2.some((address) => typeof address !== "string" || address.length === 0)) {
+    const unsignedBlockMessage = new BlockMessage({ ...blockMessage.decoded, producerProof: "" });
+    const unsignedBlockHash = await unsignedBlockMessage.hash();
+    const proofPayload = await createTransactionHash({
+      from: blockMessage.decoded.producer,
+      to: addresses.validators,
+      method: "produceBlock",
+      params: [unsignedBlockHash],
+      timestamp: Number(blockMessage.decoded.timestamp)
+    });
+    const network = globalThis.peernet?.network || "leofcoin";
+    const verifier = new MultiWallet(network);
+    await verifier.fromAddress(blockMessage.decoded.producer, null, network);
+    const validProducerProof = await verifier.verify(fromBase58(blockMessage.decoded.producerProof), proofPayload);
+    if (!validProducerProof) {
+      throw new Error(`Block ${blockMessage.decoded.index} has an invalid producerProof`);
+    }
+    const validatorAddresses = validators.map((validator) => validator.address);
+    if (validatorAddresses.some((address) => typeof address !== "string" || address.length === 0)) {
       throw new Error(`Block ${blockMessage.decoded.index} includes an invalid validator address`);
     }
-    const canonicalAddresses = [...addresses2].sort();
-    if (canonicalAddresses.some((address, index) => address !== addresses2[index])) {
+    const canonicalAddresses = [...validatorAddresses].sort();
+    if (canonicalAddresses.some((address, index) => address !== validatorAddresses[index])) {
       throw new Error(`Block ${blockMessage.decoded.index} validators are not canonically sorted`);
     }
-    if (new Set(addresses2).size !== addresses2.length) {
+    if (new Set(validatorAddresses).size !== validatorAddresses.length) {
       throw new Error(`Block ${blockMessage.decoded.index} validators contain duplicates`);
     }
     const validatorCount = BigInt(validators.length);
@@ -2545,7 +2707,7 @@ class Chain extends VersionControl {
     const hasMore = await this.hasTransactionToHandle();
     if (!hasMore && remaining > 0) await this.#sleep(remaining);
     this.#runningEpoch = false;
-    if (hasMore) return this.#runEpoch();
+    if (hasMore && !this.#proposalInFlight) return this.#runEpoch();
   }
   async #setup() {
     const contracts = [
@@ -2981,29 +3143,15 @@ class Chain extends VersionControl {
     const blockMessage = await new BlockMessage(block);
     const hash = await blockMessage.hash();
     const blockIndex = Number(blockMessage.decoded.index);
-    const existingBlockAtHeight = this.#blocks[blockIndex];
-    if (existingBlockAtHeight) {
-      if (existingBlockAtHeight.hash !== hash) {
-        console.error(`  Local:  ${existingBlockAtHeight.hash}`);
-        console.error(`  Remote: ${hash}`);
-        throw new Error(`Block conflict detected at index ${blockIndex}`);
-      }
-      debug(`Block already in store: ${hash}`);
+    const linkResult = validateChainLink(await this.lastBlock, {
+      index: blockIndex,
+      hash,
+      previousHash: String(blockMessage.decoded.previousHash)
+    });
+    if (linkResult !== "append") {
+      debug(`Ignoring ${linkResult} block ${hash} at height ${blockIndex}`);
       return;
     }
-    if (blockIndex > 0) {
-      const previousBlockInfo = this.#blocks[blockIndex - 1];
-      if (!previousBlockInfo) {
-        throw new Error(`Missing parent block at index ${blockIndex - 1}`);
-      }
-      if (previousBlockInfo.hash !== blockMessage.decoded.previousHash) {
-        throw new Error(
-          `previousHash mismatch at index ${blockIndex}: expected ${previousBlockInfo.hash}, got ${blockMessage.decoded.previousHash}`
-        );
-      }
-    } else if (blockMessage.decoded.previousHash !== "0x0") {
-      throw new Error(`Genesis block (index 0) must have previousHash='0x0'`);
-    }
     const canonicalEncoded = blockMessage.encoded;
     const byteLengthMatch = receivedEncoded.length === canonicalEncoded.length;
     if (!byteLengthMatch) {
@@ -3022,14 +3170,19 @@ class Chain extends VersionControl {
       throw new Error(`[FATAL] Block data corrupted in transit for block #${blockIndex} hash ${hash}`);
     }
     console.log(`[chain] \u2705 Block data integrity verified: ${hash}`);
-    this.#validateBlockValidators(blockMessage);
+    await this.#validateBlockValidators(blockMessage);
     const transactions = await Promise.all(
       blockMessage.decoded.transactions.map(async (hash2) => {
         const data = await peernet.get(hash2, "transaction");
-        await transactionPoolStore.has(hash2) && await transactionPoolStore.delete(hash2);
         return new TransactionMessage(data);
       })
     );
+    await Promise.all(transactions.map((transaction) => this.validateTransactionSignature(transaction)));
+    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,
@@ -3046,26 +3199,11 @@ class Chain extends VersionControl {
       if (nonceDiff !== 0) return nonceDiff;
       return 0;
     });
-    const txsByAddress = /* @__PURE__ */ new Map();
     for (const transaction of allTransactions) {
-      const sender = transaction.decoded.from;
-      if (!txsByAddress.has(sender)) {
-        txsByAddress.set(sender, []);
-      }
-      txsByAddress.get(sender).push(transaction);
+      if (!contracts.includes(transaction.decoded.to)) contracts.push(transaction.decoded.to);
+      this.removePendingNonce(transaction.decoded.from, transaction.decoded.nonce);
+      await this.#handleTransaction(transaction, []);
     }
-    const addressGroups = [...txsByAddress.values()];
-    await Promise.all(
-      addressGroups.map(async (addressTxs) => {
-        for (const transaction of addressTxs) {
-          if (!contracts.includes(transaction.decoded.to)) {
-            contracts.push(transaction.decoded.to);
-          }
-          this.removePendingNonce(transaction.decoded.from, transaction.decoded.nonce);
-          await this.#handleTransaction(transaction, []);
-        }
-      })
-    );
     try {
       promises = await Promise.allSettled(promises);
       const noncesByAddress = {};
@@ -3098,7 +3236,6 @@ class Chain extends VersionControl {
     }
   }
   async participate(address) {
-    this.#participating = true;
     try {
       if (!await this.staticCall(addresses.validators, "has", [address])) {
         const rawTransaction = {
@@ -3110,18 +3247,20 @@ class Chain extends VersionControl {
           timestamp: Date.now()
         };
         const transaction = await signTransaction(rawTransaction, globalThis.peernet.identity);
-        try {
-          await this.sendTransaction(transaction);
-        } catch (error) {
-          console.error(error);
-        }
+        await this.sendTransaction(transaction);
+        this.#participating = false;
+        return false;
       }
     } catch (error) {
-      debug("Error in participate:", error.message);
+      this.#participating = false;
+      throw new Error(`validator participation failed: ${error?.message ?? error}`);
     }
+    this.#participating = true;
     if (await this.hasTransactionToHandle() && !this.#runningEpoch && this.#participating) await this.#runEpoch();
+    return true;
   }
   async #handleTransaction(transaction, latestTransactions, block) {
+    await this.validateTransactionSignature(transaction);
     const hash = await transaction.hash();
     const doubleTransactions = [];
     if (latestTransactions.includes(hash) || await transactionStore.has(hash)) {
@@ -3153,12 +3292,13 @@ class Chain extends VersionControl {
   }
   // todo filter tx that need to wait on prev nonce
   async #createBlock(limit = this.transactionLimit) {
+    if (this.#proposalInFlight) return;
     console.log(await globalThis.transactionPoolStore.size());
     if (await globalThis.transactionPoolStore.size() === 0) return;
     let transactions = await globalThis.transactionPoolStore.values(this.transactionLimit);
     if (Object.keys(transactions)?.length === 0) return;
     const timestamp = Date.now();
-    let block = {
+    const block = {
       transactions: [],
       validators: [],
       fees: BigInt(0),
@@ -3180,70 +3320,17 @@ class Chain extends VersionControl {
       if (nonceDiff !== 0) return nonceDiff;
       return 0;
     });
-    const txsByAddress = /* @__PURE__ */ new Map();
     for (const transaction of allTransactions) {
-      const sender = transaction.decoded.from;
-      if (!txsByAddress.has(sender)) {
-        txsByAddress.set(sender, []);
+      await this.validateTransactionSignature(transaction);
+      const hash = await transaction.hash();
+      if (latestTransactions.includes(hash) || await globalThis.transactionStore.has(hash)) {
+        continue;
       }
-      txsByAddress.get(sender).push(transaction);
+      block.transactions.push(hash);
+      block.fees += BigInt(await calculateFee(transaction.decoded));
+      await globalThis.peernet.put(hash, transaction.encoded, "transaction");
     }
-    const addressGroups = [...txsByAddress.values()];
-    await Promise.all(
-      addressGroups.map(async (addressTxs) => {
-        for (const transaction of addressTxs) {
-          await this.#handleTransaction(transaction, latestTransactions, block);
-        }
-      })
-    );
     if (block.transactions.length === 0) return;
-    const validators = await this.staticCall(addresses.validators, "validators");
-    const peers = {};
-    for (const entry of globalThis.peernet.peers) {
-      peers[entry[0]] = entry[1];
-    }
-    const finalizeBWAndBroadcast = async () => {
-      const bwPromises = validators.map(async (validator) => {
-        const peer = peers[validator];
-        if (peer && peer.connected && this.isVersionCompatible(peer.version)) {
-          try {
-            let data = await new BWRequestMessage();
-            const node = await globalThis.peernet.prepareMessage(data.encoded);
-            const bw = await peer.request(node.encoded);
-            return {
-              address: validator,
-              bw: bw.up + bw.down
-            };
-          } catch (error) {
-            const peerId = peer?.peerId || peer?.id || peer?.address || "unknown";
-            debug(`bw request failed: ${peerId}:`, error?.message ?? error);
-            return null;
-          }
-        } else if (globalThis.peernet.selectedAccount === validator) {
-          return {
-            address: globalThis.peernet.selectedAccount,
-            bw: globalThis.peernet.bw.up + globalThis.peernet.bw.down
-          };
-        }
-        return null;
-      });
-      const bwResults = await Promise.allSettled(bwPromises);
-      for (const result of bwResults) {
-        if (result.status === "fulfilled" && result.value) {
-          block.validators.push(result.value);
-        }
-      }
-    };
-    finalizeBWAndBroadcast().catch((error) => {
-      debug(`background BW finalization failed:`, error?.message ?? error);
-    });
-    block.validators = block.validators.map((validator) => {
-      validator.reward = block.fees;
-      validator.reward += block.reward;
-      validator.reward /= BigInt(block.validators.length);
-      delete validator.bw;
-      return validator;
-    });
     const localBlock = await this.lastBlock;
     block.index = localBlock.index;
     if (block.index === void 0) block.index = 0;
@@ -3251,17 +3338,12 @@ class Chain extends VersionControl {
     block.previousHash = localBlock.hash || "0x0";
     const canonicalValidators = await this.staticCall(addresses.validators, "validators");
     const sortedValidators = [...canonicalValidators].sort();
+    if (sortedValidators.length === 0) throw new Error("cannot produce a block without validators");
     block.validators = sortedValidators.map((validatorAddress) => ({
       address: validatorAddress,
       reward: block.fees / BigInt(sortedValidators.length) + block.reward / BigInt(sortedValidators.length)
     }));
     try {
-      await Promise.all(
-        block.transactions.map(async (transaction) => {
-          await globalThis.transactionStore.put(transaction, await transactionPoolStore.get(transaction));
-          await globalThis.transactionPoolStore.delete(transaction);
-        })
-      );
       block.producer = globalThis.peernet.selectedAccount || "";
       const producerSigner = globalThis.peernet?.identity;
       if (block.producer && producerSigner) {
@@ -3279,19 +3361,23 @@ class Chain extends VersionControl {
         );
         block.producerProof = signedProof.signature;
       }
+      if (!block.producer || !block.producerProof) throw new Error("block producer identity is not available");
       let blockMessage = await new BlockMessage(block);
       const hash = await blockMessage.hash();
       await globalThis.peernet.put(hash, blockMessage.encoded, "block");
-      await this.machine.addLoadedBlock({ ...blockMessage.decoded, loaded: true, hash: await blockMessage.hash() });
-      await this.updateState(blockMessage);
-      debug(`created block: ${hash} @${block.index}`);
+      this.#proposalInFlight = { hash, index: block.index, round: this.#consensusRound };
+      debug(`proposed block: ${hash} @${block.index}`);
       console.log(`[consensus] \u{1F4E4} Proposing block #${block.index} | hash: ${hash} | round: ${this.#consensusRound}`);
-      const proposalData = {
+      const unsignedProposal = {
         blockHash: hash,
         index: BigInt(block.index),
         round: BigInt(this.#consensusRound),
         from: peernet.selectedAccount
       };
+      const proposalData = {
+        ...unsignedProposal,
+        signature: await this.#signConsensusMessage("proposal", unsignedProposal)
+      };
       const proposalMessage = new ProposalMessage(proposalData);
       const proposalPayload = proposalMessage.encoded;
       try {
@@ -3300,6 +3386,16 @@ class Chain extends VersionControl {
         debug("peernet publish failed: consensus:propose", publishError?.message ?? publishError);
       }
       await this.#castVote("prevote", hash, block.index, this.#consensusRound);
+      if (!this.#roundTimer && this.#proposalInFlight?.hash === hash) {
+        this.#roundTimer = setTimeout(async () => {
+          this.#roundTimer = null;
+          if (this.#proposalInFlight?.hash !== hash) return;
+          this.#proposalInFlight = null;
+          this.#consensusRound += 1;
+          this.#runningEpoch = false;
+          if (this.#participating) await this.#runEpoch();
+        }, this.#slotTime);
+      }
     } catch (error) {
       console.log(error);
       throw new Error(`invalid block ${block}`);
@@ -3307,6 +3403,7 @@ class Chain extends VersionControl {
   }
   async #sendTransaction(transaction) {
     transaction = await new TransactionMessage(transaction.encoded || transaction);
+    await this.validateTransactionSignature(transaction);
     const hash = await transaction.hash();
     try {
       const has = await globalThis.transactionPoolStore.has(hash);