@leofcoin/chain 1.8.29 → 1.9.0

package/exports/browser/chain.js

@@ -1,4 +1,4 @@
-import { t as toBase58, T as TransactionMessage, C as ContractMessage, R as RawTransactionMessage, B as BlockMessage, u as utils, L as LastBlockMessage, P as PROTOCOL_VERSION, a as REACHED_ONE_ZERO_ZERO, b as BWMessage, c as BWRequestMessage } from './constants-BKKQytjd.js';
+import { t as toBase58, T as TransactionMessage, C as ContractMessage, R as RawTransactionMessage, B as BlockMessage, u as utils, L as LastBlockMessage, P as PROTOCOL_VERSION, a as REACHED_ONE_ZERO_ZERO, b as BWMessage, c as BWRequestMessage } from './constants-BTdMMS4w.js';
 import { log } from 'console';
 import { log as log$1 } from 'node:console';
 
@@ -964,7 +964,7 @@ function parseUnits(value, unit) {
 }
 
 const jsonStringifyBigInt = (key, value) => (typeof value === 'bigint' ? { $bigint: value.toString() } : value);
-const jsonParseBigInt = (key, value) => typeof value === 'object' && value.$bigint ? BigInt(value.$bigint) : value;
+const jsonParseBigInt = (key, value) => typeof value === 'object' && value?.$bigint ? BigInt(value.$bigint) : value;
 
 const byteFormats = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
 const formatBytes = (bytes, decimals = 2) => {
@@ -3921,8 +3921,6 @@ class Transaction extends Protocol {
         transactions = await this.promiseTransactions(transactions);
         transactions = transactions.filter((tx) => tx.decoded.from === address);
         for (const transaction of transactions) {
-            if (transaction.decoded.nonce > nonce)
-                throw new Error(`a transaction with a higher nonce already exists`);
             if (transaction.decoded.nonce === nonce)
                 throw new Error(`a transaction with the same nonce already exists`);
         }
@@ -4356,82 +4354,121 @@ class Contract extends Transaction {
 
 const randombytes = (strength) => crypto.getRandomValues(new Uint8Array(strength));
 
-class EasyWorker {
-  #messageEvent = 'message'
-  #errorEvent = 'error'
-  #isBrowser = false
-  #isWorker = false
-
-  get isWorker() {
-    return this.#isWorker
-  }
-  constructor(url, options) {
-    return this.#init(url, options)
-  }
-
-  #init(url, options = {}) {
-    if (url) {
-      if (globalThis.Worker) {
-        this.#isBrowser = true;
-        this.worker = new Worker(url, {...options});
-      } else {
-        return new Promise(async (resolve, reject) => {
-          const {fork} = await import('child_process');  
-          this.worker = fork(url, ['easy-worker-child'], options);
-          resolve(this);
-        })
-      }
-    } else {
-      this.#isWorker = true;
-      if (globalThis.process?.argv[2] === 'easy-worker-child') {
-        this.worker = process;
-      } else {
-        this.#isBrowser = true;
-        this.worker = globalThis;
-      }
-    }
-    
-    return this
-  }
-
-  onmessage(fn) {
-    if (this.#isBrowser) this.worker.onmessage = ({data}) => fn(data);
-    else this.worker.on(this.#messageEvent, fn);
-  }
-
-  postMessage(message) {
-    if (this.#isBrowser) this.worker.postMessage(message);
-    else this.worker.send(message);
-  }
-
-  terminate() {
-    if (this.#isBrowser) this.worker.terminate();
-    else this.worker.kill();
-  }
-
-  onerror(fn) {
-    if (this.#isBrowser) this.worker.onerror = fn;
-    else this.worker.on(this.#errorEvent, fn);
-  }
-
-  /**
-   * 
-   * @param {*} data 
-   * @returns {Promise} resolves result onmessage & rejects on error
-   */
-  once(data) {
-    return new Promise((resolve, reject) => {
-      this.onmessage(message => {
-        resolve(message);
-        this.terminate();
-      });
-      this.onerror(error => {
-        reject(error);
-        this.terminate();
-      });
-      this.postMessage(data);
-    })    
-  }  
+class EasyWorker {
+    #messageEvent = 'message';
+    #errorEvent = 'error';
+    #isBrowser = false;
+    #isWorker = false;
+    #messageHandler = null;
+    #errorHandler = null;
+    worker;
+    get isWorker() {
+        return this.#isWorker;
+    }
+    constructor(url, options) {
+        return this.#init(url, options);
+    }
+    #init(url, options = {}) {
+        if (url) {
+            if (globalThis.Worker) {
+                this.#isBrowser = true;
+                this.worker = new Worker(url, { ...options });
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    import('child_process').then(({ fork }) => {
+                        const child = fork(url, ['easy-worker-child'], options);
+                        child.once('error', reject);
+                        this.worker = child;
+                        resolve(this);
+                    }).catch(reject);
+                });
+            }
+        }
+        else {
+            this.#isWorker = true;
+            if (globalThis.process?.argv[2] === 'easy-worker-child') {
+                this.worker = process;
+            }
+            else {
+                this.#isBrowser = true;
+                this.worker = globalThis;
+            }
+        }
+        return this;
+    }
+    onmessage(fn) {
+        if (this.#isBrowser) {
+            this.worker.onmessage = ({ data }) => fn(data);
+        }
+        else {
+            if (this.#messageHandler)
+                this.worker.off(this.#messageEvent, this.#messageHandler);
+            this.#messageHandler = fn;
+            this.worker.on(this.#messageEvent, fn);
+        }
+    }
+    postMessage(message) {
+        if (this.#isBrowser)
+            this.worker.postMessage(message);
+        else
+            this.worker.send(message);
+    }
+    terminate() {
+        if (this.#isBrowser)
+            this.worker.terminate();
+        else
+            this.worker.kill();
+    }
+    onerror(fn) {
+        if (this.#isBrowser) {
+            this.worker.onerror = fn;
+        }
+        else {
+            if (this.#errorHandler)
+                this.worker.off(this.#errorEvent, this.#errorHandler);
+            this.#errorHandler = fn;
+            this.worker.on(this.#errorEvent, fn);
+        }
+    }
+    /**
+     *
+     * @param {*} data
+     * @returns {Promise} resolves result onmessage & rejects on error
+     */
+    once(data) {
+        return new Promise((resolve, reject) => {
+            if (this.#isBrowser) {
+                const handleMessage = ({ data: result }) => {
+                    this.worker.onerror = null;
+                    resolve(result);
+                    this.terminate();
+                };
+                const handleError = (error) => {
+                    this.worker.onmessage = null;
+                    reject(error);
+                    this.terminate();
+                };
+                this.worker.onmessage = handleMessage;
+                this.worker.onerror = handleError;
+            }
+            else {
+                const handleMessage = (result) => {
+                    this.worker.off(this.#errorEvent, handleError);
+                    resolve(result);
+                    this.terminate();
+                };
+                const handleError = (error) => {
+                    this.worker.off(this.#messageEvent, handleMessage);
+                    reject(error);
+                    this.terminate();
+                };
+                this.worker.once(this.#messageEvent, handleMessage);
+                this.worker.once(this.#errorEvent, handleError);
+            }
+            this.postMessage(data);
+        });
+    }
 }
 
 class LeofcoinError extends Error {
@@ -4630,20 +4667,30 @@ class Machine {
                     }
                     await Promise.all(promises);
                 }
+                // Helper to sort object keys for deterministic serialization
+                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', JSON.stringify(await this.lastBlock, jsonStringifyBigInt)),
-                    stateStore.put('states', JSON.stringify(state, jsonStringifyBigInt)),
-                    stateStore.put('accounts', JSON.stringify(accounts, jsonStringifyBigInt)),
-                    stateStore.put('info', JSON.stringify({
+                    stateStore.put('lastBlock', sortedStringify(await this.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,
-                        nativeBurns: await this.nativeBurns,
                         nativeTransfers: await this.nativeTransfers,
-                        totalTransactions: await this.totalTransactions,
+                        totalBlocks: await blockStore.length,
                         totalBurnAmount: await this.totalBurnAmount,
                         totalMintAmount: await this.totalMintAmount,
-                        totalTransferAmount: await this.totalTransferAmount,
-                        totalBlocks: await blockStore.length
+                        totalTransactions: await this.totalTransactions,
+                        totalTransferAmount: await this.totalTransferAmount
                     }, jsonStringifyBigInt))
                     // accountsStore.clear()
                 ];
@@ -5016,6 +5063,7 @@ class State extends Contract {
     #totalSize;
     #machine;
     #loaded;
+    #resolvingHashes;
     /**
      * contains transactions we need before we can successfully load
      */
@@ -5104,6 +5152,7 @@ class State extends Contract {
         this.knownBlocks = [];
         this.#totalSize = 0;
         this.#loaded = false;
+        this.#resolvingHashes = new Set();
         this._wantList = [];
         this.#chainStateHandler = () => {
             return new globalThis.peernet.protos['peernet-response']({
@@ -5264,6 +5313,23 @@ class State extends Contract {
         }
         return block;
     }
+    async #resolveTransactions(transactions) {
+        await Promise.all(transactions
+            .filter((hash) => Boolean(hash))
+            .map(async (hash) => {
+            // should be in a transaction store already
+            const exists = await transactionStore.has(hash);
+            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 inPool = await transactionPoolStore.has(hash);
+            if (inPool)
+                await transactionPoolStore.delete(hash);
+        }));
+    }
     async #resolveBlock(hash) {
         let index = this.#blockHashMap.get(hash);
         let localHash = '0x0';
@@ -5289,31 +5355,12 @@ class State extends Contract {
         }
         try {
             const block = await this.getAndPutBlock(hash);
+            const promises = [];
             if (block.decoded.previousHash !== '0x0' && block.decoded.previousHash !== localHash) {
-                setImmediate(async () => {
-                    try {
-                        await this.resolveBlock(block.decoded.previousHash);
-                    }
-                    catch (e) {
-                        console.error(e);
-                    }
-                });
+                promises.push(this.resolveBlock(block.decoded.previousHash));
             }
-            await Promise.all(block.decoded.transactions
-                .filter((hash) => Boolean(hash))
-                .map(async (hash) => {
-                // should be in a transaction store already
-                const exists = await transactionStore.has(hash);
-                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 inPool = await transactionPoolStore.has(hash);
-                if (inPool)
-                    await transactionPoolStore.delete(hash);
-            }));
+            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;
@@ -5334,14 +5381,20 @@ class State extends Contract {
             throw new Error(`expected hash, got: ${hash}`);
         if (hash === '0x0')
             return;
-        if (this.#resolving)
-            return 'already resolving';
+        if (this.#resolvingHashes.has(hash))
+            return;
+        this.#resolvingHashes.add(hash);
+        const isEntering = this.#resolvingHashes.size === 1;
         this.#resolving = true;
-        if (this.jobber.busy && this.jobber.destroy)
-            await this.jobber.destroy();
         try {
-            await this.jobber.add(() => this.#resolveBlock(hash));
-            this.#resolving = false;
+            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) {
@@ -5350,19 +5403,23 @@ class State extends Contract {
                 }
             }
             catch (error) { }
-            if (!this.#blockHashMap.has(this.#lastResolved.previousHash) && this.#lastResolved.previousHash !== '0x0')
-                return this.resolveBlock(this.#lastResolved.previousHash);
         }
         catch (error) {
             console.log({ error });
             this.#resolveErrorCount += 1;
-            this.#resolving = false;
-            if (this.#resolveErrorCount < 3)
+            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 {
+            this.#resolvingHashes.delete(hash);
+            if (this.#resolvingHashes.size === 0)
+                this.#resolving = false;
+        }
     }
     async resolveBlocks() {
         // Don't re-resolve if already syncing or resolving
@@ -5484,14 +5541,29 @@ class State extends Contract {
                 debug$1(`Remote block hash is 0x0, skipping sync`);
                 return;
             }
+            // Skip if local machine is already ahead of remote
+            if (localIndex > remoteIndex) {
+                debug$1(`Local index ${localIndex} is ahead of remote ${remoteIndex}, skipping sync`);
+                return;
+            }
+            // CRITICAL: Prevent DoS from excessive reorgs
+            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})`);
+            }
             // Use state hash comparison: only resolve if remote hash differs from local state hash
             if (localStateHash !== remoteBlockHash) {
                 if (this.wantList.length > 0) {
                     debug$1(`Fetching ${this.wantList.length} blocks before resolving`);
                     const getBatch = async (batch) => {
-                        return Promise.all(batch.map((hash) => this.getAndPutBlock(hash).catch((e) => {
+                        const blocks = await Promise.all(batch.map((hash) => this.getAndPutBlock(hash).catch((e) => {
                             console.warn(`failed to fetch block ${hash}`, e);
                         })));
+                        const transactions = blocks.filter((block) => Boolean(block)).flatMap((block) => block.decoded.transactions);
+                        return this.#resolveTransactions(transactions);
                     };
                     // Process in batches of 50 to avoid overwhelming network/memory
                     for (let i = 0; i < this.wantList.length; i += 50) {
@@ -5542,11 +5614,19 @@ class State extends Contract {
         for (const id in globalThis.peernet.connections) {
             // @ts-ignore
             const peer = globalThis.peernet.connections[id];
-            if (peer.connected && peer.version === this.version) {
+            // CRITICAL FIX: Use semver comparison (major.minor) not exact match
+            const isVersionCompatible = () => {
+                if (!peer.version || !this.version)
+                    return false;
+                const [peerMajor, peerMinor] = peer.version.split('.');
+                const [localMajor, localMinor] = this.version.split('.');
+                return peerMajor === localMajor && peerMinor === localMinor;
+            };
+            if (peer.connected && isVersionCompatible()) {
                 const task = async () => {
                     try {
                         const result = await peer.request(node.encoded);
-                        debug$1({ result });
+                        debug$1(`lastBlock result: ${JSON.stringify(result)}`);
                         console.log({ result });
                         return { result: new LastBlockMessage(result), peer };
                     }
@@ -5561,7 +5641,7 @@ class State extends Contract {
         }
         // @ts-ignore
         console.log({ promises });
-        promises = await this.promiseRequests(promises);
+        promises = (await this.promiseRequests(promises));
         console.log({ promises });
         let latest = { index: 0, hash: '0x0', previousHash: '0x0' };
         promises = promises.sort((a, b) => b.index - a.index);
@@ -5576,7 +5656,15 @@ class State extends Contract {
                 throw new Error('invalid block @getLatestBlock');
             latest = { ...message.decoded, hash };
             const peer = promises[0].peer;
-            if (peer.connected && peer.version === this.version) {
+            // CRITICAL FIX: Check version compatibility using semver
+            const isVersionCompatible = () => {
+                if (!peer.version || !this.version)
+                    return false;
+                const [peerMajor, peerMinor] = peer.version.split('.');
+                const [localMajor, localMinor] = this.version.split('.');
+                return peerMajor === localMajor && peerMinor === localMinor;
+            };
+            if (peer.connected && isVersionCompatible()) {
                 let data = await new globalThis.peernet.protos['peernet-request']({
                     request: 'knownBlocks'
                 });
@@ -5584,7 +5672,11 @@ class State extends Contract {
                 try {
                     let message = await peer.request(node.encode());
                     message = await new globalThis.peernet.protos['peernet-response'](message);
-                    this.wantList.push(...message.decoded.response.blocks.filter((block) => !this.knownBlocks.includes(block)));
+                    const MAX_WANTLIST_SIZE = 1000;
+                    const incoming = message.decoded.response.blocks.filter((block) => !this.knownBlocks.includes(block));
+                    const remaining = MAX_WANTLIST_SIZE - this.wantList.length;
+                    if (remaining > 0)
+                        this.wantList.push(...incoming.slice(0, remaining));
                 }
                 catch (error) {
                     const peerId = peer?.peerId || peer?.id || peer?.address || 'unknown';
@@ -5639,7 +5731,7 @@ class State extends Contract {
             if (block && !block.loaded) {
                 try {
                     debug$1(`loading block: ${Number(block.index)} ${block.hash}`);
-                    let transactions = await this.#loadBlockTransactions([...block.transactions] || []);
+                    let transactions = await this.#loadBlockTransactions(block.transactions || []);
                     // const lastTransactions = await this.#getLastTransactions()
                     debug$1(`loading transactions: ${transactions.length} for block ${block.index}`);
                     let priority = [];
@@ -5815,6 +5907,13 @@ class VersionControl extends State {
             return this.#setCurrentVersion();
         }
     }
+    isVersionCompatible(peerVersion) {
+        if (!peerVersion || !this.version)
+            return false;
+        const [peerMajor, peerMinor] = peerVersion.split('.');
+        const [localMajor, localMinor] = this.version.split('.');
+        return peerMajor === localMajor && peerMinor === localMinor;
+    }
 }
 
 /**
@@ -5936,14 +6035,12 @@ class ConnectionMonitor {
         }
         const connectedPeers = this.connectedPeers;
         const compatiblePeers = this.compatiblePeers;
-        console.log(`🔍 Health check: ${connectedPeers.length} connected, ${compatiblePeers.length} compatible`);
-        // If a reconnection is already ongoing, skip this cycle to avoid log spam/loops
-        if (this.#reconnecting) {
-            console.log('⏭️ Health check: reconnection already in progress, skipping reconnect attempt');
-            return;
-        }
-        // If we have no connections or none are compatible, try to reconnect
-        if (connectedPeers.length === 0) {
+        const disconnectedPeers = this.disconnectedPeers;
+        console.log(`🔍 Health check: ${connectedPeers.length} connected, ${compatiblePeers.length} compatible, ${disconnectedPeers.length} negotiating`);
+        // If we have no connections or none are compatible, try to reconnect.
+        // Don't trigger reconnection if peers are still in WebRTC ICE negotiation (disconnectedPeers > 0) —
+        // reinit() would tear down the in-flight handshake.
+        if (connectedPeers.length === 0 && disconnectedPeers.length === 0) {
             console.warn('⚠️ No peer connections detected — attempting reconnection');
             await this.#attemptReconnection();
         }
@@ -6045,25 +6142,12 @@ class ConnectionMonitor {
                     console.warn('  ⚠️ peernet.start() failed:', e?.message || e);
                 }
             }
-            // Approach 3: Try client.connect if available
-            if (globalThis.peernet?.client &&
-                'connect' in globalThis.peernet.client &&
-                typeof globalThis.peernet.client.connect === 'function') {
-                console.log('  → Trying client.connect()');
-                try {
-                    await globalThis.peernet.client.connect();
-                    console.log('  ✅ client.connect() succeeded');
-                }
-                catch (e) {
-                    console.warn('  ⚠️ client.connect() failed:', e?.message || e);
-                }
-            }
-            // Approach 4: Explicitly dial star servers if available
+            // Approach 3: Explicitly dial star servers if available (only if client.reinit() didn't succeed)
             try {
                 const networkName = globalThis.peernet?.network;
                 if (networkName && typeof networkName === 'string') {
                     // Try to import network config
-                    const { default: networks } = await import('./constants-BKKQytjd.js').then(function (n) { return n.n; });
+                    const { default: networks } = await import('./constants-BTdMMS4w.js').then(function (n) { return n.n; });
                     const [mainKey, subKey] = networkName.split(':');
                     const networkConfig = networks?.[mainKey]?.[subKey];
                     if (networkConfig?.stars && Array.isArray(networkConfig.stars)) {
@@ -6074,11 +6158,6 @@ class ConnectionMonitor {
                                     await globalThis.peernet.client.dial(star);
                                     console.log(`  ✅ Connected to star server: ${star}`);
                                 }
-                                else if (globalThis.peernet?.client && 'connect' in globalThis.peernet.client) {
-                                    // Try connect with the star URL
-                                    await globalThis.peernet.client.connect(star);
-                                    console.log(`  ✅ Connected to star server: ${star}`);
-                                }
                             }
                             catch (e) {
                                 console.warn(`  ⚠️ Failed to dial ${star}:`, e?.message || e);
@@ -6120,14 +6199,13 @@ class ConnectionMonitor {
         });
     }
     async #attemptReconnection() {
-        if (this.#reconnecting) {
-            console.log('⏭️ Reconnection already in progress');
-            return;
-        }
         try {
             await this.#restoreNetwork();
-            // Check if reconnection was successful
-            const hasConnections = this.connectedPeers.length > 0;
+            // Check if reconnection was successful.
+            // Treat peers that are still negotiating (in connections but not yet connected) as success —
+            // they were discovered via the star and WebRTC ICE is in progress. Retrying now would call
+            // reinit() again and tear down the in-flight handshake.
+            const hasConnections = this.connectedPeers.length > 0 || this.disconnectedPeers.length > 0;
             if (hasConnections) {
                 console.log('✅ Reconnection successful, resetting backoff delay');
                 this.#reconnectDelay = 5000;
@@ -6177,35 +6255,252 @@ class Chain extends VersionControl {
     #state;
     #slotTime;
     #blockTime; // 6 second target block time
+    #epochLength; // Blocks per epoch (enables block-based epoch boundaries)
     /** {Address[]} */
     #validators;
     /** {Boolean} */
     #runningEpoch;
+    /** Block height at which current epoch started (for block-based epoch timing) */
+    #currentEpochStartHeight;
+    /** {Object} Block cache by index for conflict detection: {index: {hash, ...block}} */
+    #blocks;
     #participants;
     #participating;
     #jail;
+    #jailReleaseTimers;
     #peerConnectionRetries;
     #maxPeerRetries;
     #peerRetryDelay;
+    /** {Map} Peer reputation tracking: {peerId: {score, failures}} */
+    #peerReputations;
+    #minPeerScore;
+    #maxPeerFailures;
+    // ── Tendermint consensus state ──────────────────────────────────────────────
+    /** Current consensus round (increments when proposer is unresponsive) */
+    #consensusRound;
+    /** Timer that advances #consensusRound when the proposer doesn't propose in time */
+    #roundTimer;
+    /** prevotes collected per `height:round:blockHash` key */
+    #prevotes;
+    /** precommits collected per `height:round:blockHash` key */
+    #precommits;
+    /** Index of the last block that reached 2f+1 precommits */
+    #committedHeight;
+    /** Prevents casting duplicate prevote/precommit per height:round */
+    #castedVotes;
+    // ────────────────────────────────────────────────────────────────────────────
     #connectionMonitor;
     constructor(config) {
         super(config);
         this.#slotTime = 10000;
         this.#blockTime = 6000; // 6 second target block time
+        this.#epochLength = 10; // Blocks per epoch (enables block-based epoch boundaries)
         this.utils = {};
         /** {Address[]} */
         this.#validators = [];
         /** {Boolean} */
         this.#runningEpoch = false;
+        /** Block height at which current epoch started (for block-based epoch timing) */
+        this.#currentEpochStartHeight = 0;
+        /** {Object} Block cache by index for conflict detection: {index: {hash, ...block}} */
+        this.#blocks = {};
         this.#participants = [];
         this.#participating = false;
-        this.#jail = [];
+        this.#jail = new Set();
+        this.#jailReleaseTimers = new Map();
         this.#peerConnectionRetries = new Map();
         this.#maxPeerRetries = 5;
         this.#peerRetryDelay = 5000;
+        /** {Map} Peer reputation tracking: {peerId: {score, failures}} */
+        this.#peerReputations = new Map();
+        this.#minPeerScore = -10;
+        this.#maxPeerFailures = 100;
+        // ── Tendermint consensus state ──────────────────────────────────────────────
+        /** Current consensus round (increments when proposer is unresponsive) */
+        this.#consensusRound = 0;
+        /** Timer that advances #consensusRound when the proposer doesn't propose in time */
+        this.#roundTimer = null;
+        /** prevotes collected per `height:round:blockHash` key */
+        this.#prevotes = new Map();
+        /** precommits collected per `height:round:blockHash` key */
+        this.#precommits = new Map();
+        /** Index of the last block that reached 2f+1 precommits */
+        this.#committedHeight = -1;
+        /** Prevents casting duplicate prevote/precommit per height:round */
+        this.#castedVotes = new Set();
         this.ready = new Promise((resolve) => {
             this.readyResolve = resolve;
         });
+        // ── Tendermint consensus handlers ────────────────────────────────────────
+        /**
+         * Publish a prevote or precommit.  Idempotent — will not cast the same
+         * vote twice for the same height:round.
+         */
+        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 payload = new TextEncoder().encode(JSON.stringify({ blockHash, index, round, from }));
+            try {
+                globalThis.peernet.publish(`consensus:${type}`, payload);
+            }
+            catch (e) {
+                debug(`peernet publish failed: consensus:${type}`, e?.message ?? e);
+            }
+        };
+        /**
+         * Phase 2 — receive a block proposal from the designated proposer.
+         * Validates the proposer is correct for height/round, fetches + validates
+         * the block from peernet, then casts a prevote.
+         */
+        this.#handleProposal = async (payload) => {
+            try {
+                const msg = JSON.parse(new TextDecoder().decode(payload));
+                const { blockHash, index, round, from } = msg;
+                const validators = await this.#getConsensusValidators(index);
+                const expectedProposerIdx = (index + round) % validators.length;
+                if (!validators[expectedProposerIdx] || validators[expectedProposerIdx] !== from) {
+                    debug(`[consensus] Proposal from wrong proposer at height ${index} round ${round}`);
+                    return;
+                }
+                const localBlock = await this.lastBlock;
+                const localIndex = localBlock?.index !== undefined ? Number(localBlock.index) : -1;
+                if (index <= localIndex) {
+                    debug(`[consensus] Ignoring stale proposal at height ${index} (local: ${localIndex})`);
+                    return;
+                }
+                // Fetch block from peernet and verify its hash
+                try {
+                    const blockData = await globalThis.peernet.get(blockHash, 'block');
+                    const blockMessage = await new BlockMessage(blockData);
+                    const actualHash = await blockMessage.hash();
+                    if (actualHash !== blockHash) {
+                        debug(`[consensus] Block hash mismatch in proposal: expected ${blockHash}, got ${actualHash}`);
+                        return;
+                    }
+                }
+                catch (e) {
+                    debug(`[consensus] Cannot fetch proposed block ${blockHash}:`, e?.message);
+                    return;
+                }
+                this.#consensusRound = round;
+                if (this.#roundTimer) {
+                    clearTimeout(this.#roundTimer);
+                    this.#roundTimer = null;
+                }
+                if (validators.includes(peernet.selectedAccount) && !this.#isJailed(peernet.selectedAccount)) {
+                    await this.#castVote('prevote', blockHash, index, round);
+                }
+            }
+            catch (e) {
+                debug('[consensus] Error handling proposal:', e?.message);
+            }
+        };
+        /**
+         * Phase 2 — collect prevotes. Once 2f+1 prevotes are seen for a block,
+         * cast a precommit.
+         */
+        this.#handlePrevote = async (payload) => {
+            try {
+                const msg = JSON.parse(new TextDecoder().decode(payload));
+                const { blockHash, index, round, from } = msg;
+                const validators = await this.#getConsensusValidators(index);
+                if (!validators.includes(from))
+                    return;
+                const localBlock = await this.lastBlock;
+                const localIndex = localBlock?.index !== undefined ? Number(localBlock.index) : -1;
+                if (index <= localIndex)
+                    return;
+                const voteKey = `${index}:${round}:${blockHash}`;
+                if (!this.#prevotes.has(voteKey))
+                    this.#prevotes.set(voteKey, new Set());
+                this.#prevotes.get(voteKey).add(from);
+                const threshold = Math.ceil((2 * validators.length) / 3);
+                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)) {
+                    await this.#castVote('precommit', blockHash, index, round);
+                }
+            }
+            catch (e) {
+                debug('[consensus] Error handling prevote:', e?.message);
+            }
+        };
+        /**
+         * Phase 3 — collect precommits. Once 2f+1 precommits are seen for a block,
+         * commit it: non-proposers call #addBlock, then broadcast on add-block for
+         * syncing nodes.
+         */
+        this.#handlePrecommit = async (payload) => {
+            try {
+                const msg = JSON.parse(new TextDecoder().decode(payload));
+                const { blockHash, index, round, from } = msg;
+                const validators = await this.#getConsensusValidators(index);
+                if (!validators.includes(from))
+                    return;
+                if (index <= this.#committedHeight)
+                    return;
+                const voteKey = `${index}:${round}:${blockHash}`;
+                if (!this.#precommits.has(voteKey))
+                    this.#precommits.set(voteKey, new Set());
+                this.#precommits.get(voteKey).add(from);
+                const threshold = Math.ceil((2 * validators.length) / 3);
+                const voteCount = this.#precommits.get(voteKey).size;
+                debug(`[consensus] Precommits ${voteKey}: ${voteCount}/${validators.length} (need ${threshold})`);
+                if (voteCount >= threshold && index > this.#committedHeight) {
+                    this.#committedHeight = index;
+                    this.#consensusRound = 0;
+                    // Prune vote state for committed and older heights
+                    for (const key of [...this.#prevotes.keys()]) {
+                        if (Number(key.split(':')[0]) <= index)
+                            this.#prevotes.delete(key);
+                    }
+                    for (const key of [...this.#precommits.keys()]) {
+                        if (Number(key.split(':')[0]) <= index)
+                            this.#precommits.delete(key);
+                    }
+                    for (const key of [...this.#castedVotes]) {
+                        if (Number(key.split(':')[1]) <= index)
+                            this.#castedVotes.delete(key);
+                    }
+                    // Non-proposers add the block to local state now.
+                    // Proposers already committed state in #createBlock() and their
+                    // lastBlock.index === index, so the guard below skips them.
+                    const currentBlock = await this.lastBlock;
+                    const currentIndex = currentBlock?.index !== undefined ? Number(currentBlock.index) : -1;
+                    if (index > currentIndex) {
+                        debug(`[consensus] ✅ 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] ✅ Block ${blockHash} at height ${index} already committed (proposer path)`);
+                    }
+                    // Broadcast committed block so syncing / non-participating nodes can catch up
+                    try {
+                        const blockData = await globalThis.peernet.get(blockHash, 'block');
+                        globalThis.peernet.publish('add-block', blockData);
+                        globalThis.pubsub.publish('add-block', blockData);
+                    }
+                    catch (e) {
+                        debug('[consensus] Failed to broadcast committed block:', e?.message);
+                    }
+                }
+            }
+            catch (e) {
+                debug('[consensus] Error handling precommit:', e?.message);
+            }
+        };
+        // ─────────────────────────────────────────────────────────────────────────
         this.#addTransaction = async (message) => {
             const transaction = new TransactionMessage(message);
             const hash = await transaction.hash();
@@ -6229,17 +6524,149 @@ class Chain extends VersionControl {
     #sleep(ms) {
         return new Promise((resolve) => setTimeout(resolve, ms));
     }
+    async #recordPeerFailure(peerId, reason) {
+        if (!this.#peerReputations.has(peerId)) {
+            this.#peerReputations.set(peerId, { score: 0, failures: [] });
+        }
+        const rep = this.#peerReputations.get(peerId);
+        rep.score -= 1;
+        rep.failures.push(`${Date.now()}: ${reason}`);
+        if (rep.failures.length > this.#maxPeerFailures) {
+            rep.failures.shift();
+        }
+        if (rep.score < this.#minPeerScore) {
+            console.warn(`[peer-ban] Peer ${peerId} banned after ${rep.failures.length} failures`);
+            // Disconnect and don't reconnect
+            try {
+                await globalThis.peernet.disconnect(peerId);
+            }
+            catch (e) {
+                debug(`Failed to disconnect peer ${peerId}`);
+            }
+        }
+    }
+    #isJailed(address) {
+        return typeof address === 'string' && this.#jail.has(address);
+    }
+    async #getConsensusValidators(nextBlockIndex) {
+        const localBlock = await this.lastBlock;
+        const localIndex = localBlock?.index !== undefined ? Number(localBlock.index) : -1;
+        if (Array.isArray(localBlock?.validators) &&
+            localBlock.validators.length > 0 &&
+            (nextBlockIndex === undefined || nextBlockIndex === localIndex + 1)) {
+            return [
+                ...new Set(localBlock.validators
+                    .map((validator) => validator.address)
+                    .filter((address) => Boolean(address)))
+            ].sort();
+        }
+        const validators = (await this.staticCall(addresses.validators, 'validators'));
+        return [...new Set(validators)].sort();
+    }
+    #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`);
+        }
+        // Validate protocol version compatibility
+        if (!blockMessage.decoded.protocolVersion || typeof blockMessage.decoded.protocolVersion !== 'string') {
+            throw new Error(`Block ${blockMessage.decoded.index} does not have a valid protocolVersion field`);
+        }
+        if (!this.isVersionCompatible(blockMessage.decoded.protocolVersion)) {
+            throw new Error(`Block ${blockMessage.decoded.index} uses incompatible protocol version: ${blockMessage.decoded.protocolVersion} ` +
+                `(local: ${this.version}). Major.minor version must match.`);
+        }
+        // Validate producer field
+        if (!blockMessage.decoded.producer || typeof blockMessage.decoded.producer !== 'string') {
+            throw new Error(`Block ${blockMessage.decoded.index} does not have a valid producer field`);
+        }
+        // Validate producerProof field
+        if (!blockMessage.decoded.producerProof || typeof blockMessage.decoded.producerProof !== 'string') {
+            throw new Error(`Block ${blockMessage.decoded.index} does not have a valid producerProof field`);
+        }
+        // Verify producer is in validators list
+        const producerIsValidator = validators.some((v) => v.address === blockMessage.decoded.producer);
+        if (!producerIsValidator) {
+            throw new Error(`Block ${blockMessage.decoded.index} producer ${blockMessage.decoded.producer} is not in validators list`);
+        }
+        const addresses = validators.map((validator) => validator.address);
+        if (addresses.some((address) => typeof address !== 'string' || address.length === 0)) {
+            throw new Error(`Block ${blockMessage.decoded.index} includes an invalid validator address`);
+        }
+        const canonicalAddresses = [...addresses].sort();
+        if (canonicalAddresses.some((address, index) => address !== addresses[index])) {
+            throw new Error(`Block ${blockMessage.decoded.index} validators are not canonically sorted`);
+        }
+        if (new Set(addresses).size !== addresses.length) {
+            throw new Error(`Block ${blockMessage.decoded.index} validators contain duplicates`);
+        }
+        const validatorCount = BigInt(validators.length);
+        const expectedReward = blockMessage.decoded.fees / validatorCount + blockMessage.decoded.reward / validatorCount;
+        for (const validator of validators) {
+            if (validator.reward !== expectedReward) {
+                throw new Error(`Block ${blockMessage.decoded.index} has an invalid reward for validator ${validator.address}: ` +
+                    `expected ${expectedReward}, got ${validator.reward}`);
+            }
+        }
+    }
+    /** Check if the next block will cross an epoch boundary (block-based timing) */
+    #isEpochBoundary(blockHeight) {
+        return (blockHeight + 1) % this.#epochLength === 0;
+    }
+    /** Handle epoch transition when a block crosses epoch boundary */
+    async #handleEpochBoundary(blockHeight) {
+        if (!this.#isEpochBoundary(blockHeight))
+            return;
+        // Epoch boundary crossed: update epoch start, reset round, trigger validator rotation
+        this.#currentEpochStartHeight = blockHeight + 1;
+        this.#consensusRound = 0;
+        debug(`[consensus] Epoch boundary at block ${blockHeight}: new epoch starts at height ${this.#currentEpochStartHeight}`);
+        // If we're participating as a validator, trigger immediate epoch to determine new proposer
+        if (this.#participating && !this.#runningEpoch) {
+            await this.#runEpoch();
+        }
+    }
     async #runEpoch() {
         if (this.#runningEpoch)
             return;
         this.#runningEpoch = true;
         console.log('epoch');
-        const validators = await this.staticCall(addresses.validators, 'validators');
+        const validators = await this.#getConsensusValidators();
         console.log({ validators });
+        if (this.#isJailed(peernet.selectedAccount)) {
+            this.#runningEpoch = false;
+            return;
+        }
         if (!validators.includes(peernet.selectedAccount)) {
             this.#runningEpoch = false;
             return;
         }
+        // Phase 1: Deterministic proposer selection
+        // proposer = validators[(nextBlockIndex + round) % validators.length]
+        const localBlock = await this.lastBlock;
+        const nextIndex = (localBlock?.index !== undefined ? Number(localBlock.index) : -1) + 1;
+        const proposerIdx = (nextIndex + this.#consensusRound) % validators.length;
+        const isProposer = validators[proposerIdx] === peernet.selectedAccount;
+        if (!isProposer) {
+            // Non-proposer: start round-advance timer in case proposer is unresponsive
+            if (!this.#roundTimer) {
+                this.#roundTimer = setTimeout(async () => {
+                    this.#roundTimer = null;
+                    this.#consensusRound++;
+                    debug(`[consensus] Round timed out, advancing to round ${this.#consensusRound}`);
+                    this.#runningEpoch = false;
+                    if (this.#participating)
+                        await this.#runEpoch();
+                }, this.#slotTime);
+            }
+            this.#runningEpoch = false;
+            return;
+        }
+        // We are the proposer — clear any stale round-advance timer
+        if (this.#roundTimer) {
+            clearTimeout(this.#roundTimer);
+            this.#roundTimer = null;
+        }
         const start = Date.now();
         try {
             await this.#createBlock();
@@ -6324,6 +6751,10 @@ class Chain extends VersionControl {
         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));
+        // Tendermint consensus topics
+        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));
         globalThis.pubsub.subscribe('peer:connected', this.#peerConnected.bind(this));
         globalThis.pubsub.publish('chain:ready', true);
         console.log('[chain] init:done');
@@ -6339,11 +6770,44 @@ class Chain extends VersionControl {
         await globalThis.transactionPoolStore.delete(hash);
     }
     async #validatorTimeout(validatorInfo) {
-        setTimeout(() => {
-            this.#jail.splice(this.#jail.indexOf(validatorInfo.address), 1);
-        }, validatorInfo.timeout);
-        this.#jail.push(validatorInfo.address);
-    }
+        const address = validatorInfo?.address;
+        if (!address)
+            return;
+        const timeout = Math.min(Math.max(Number(validatorInfo.timeout) || 0, 0), 60 * 60 * 1000);
+        const existingRelease = this.#jailReleaseTimers.get(address);
+        if (existingRelease)
+            clearTimeout(existingRelease);
+        this.#jail.add(address);
+        const releaseTimer = setTimeout(() => {
+            this.#jail.delete(address);
+            this.#jailReleaseTimers.delete(address);
+        }, timeout);
+        this.#jailReleaseTimers.set(address, releaseTimer);
+    }
+    // ── Tendermint consensus handlers ────────────────────────────────────────
+    /**
+     * Publish a prevote or precommit.  Idempotent — will not cast the same
+     * vote twice for the same height:round.
+     */
+    #castVote;
+    /**
+     * Phase 2 — receive a block proposal from the designated proposer.
+     * Validates the proposer is correct for height/round, fetches + validates
+     * the block from peernet, then casts a prevote.
+     */
+    #handleProposal;
+    /**
+     * Phase 2 — collect prevotes. Once 2f+1 prevotes are seen for a block,
+     * cast a precommit.
+     */
+    #handlePrevote;
+    /**
+     * Phase 3 — collect precommits. Once 2f+1 precommits are seen for a block,
+     * commit it: non-proposers call #addBlock, then broadcast on add-block for
+     * syncing nodes.
+     */
+    #handlePrecommit;
+    // ─────────────────────────────────────────────────────────────────────────
     #addTransaction;
     async #prepareRequest(request) {
         let node = await new globalThis.peernet.protos['peernet-request']({ request });
@@ -6399,17 +6863,7 @@ class Chain extends VersionControl {
         debug(`peer connected: ${peerId}`);
         const peer = peernet.getConnection(peerId);
         debug(`peer connected with version ${peer.version}`);
-        // todo handle version changes
-        // for now just do nothing if version doesn't match
-        debug(`peer connected with version ${peer.version}`);
-        const compatibleVersion = () => {
-            if (!peer.version || !this.version)
-                return false;
-            const [peerMajor, peerMinor] = peer.version.split('.');
-            const [localMajor, localMinor] = this.version.split('.');
-            return peerMajor === localMajor && peerMinor === localMinor;
-        };
-        if (!compatibleVersion()) {
+        if (!this.isVersionCompatible(peer.version)) {
             debug(`versions don't match`);
             return;
         }
@@ -6423,9 +6877,19 @@ class Chain extends VersionControl {
         catch (error) {
             const peerName = peer?.peerId || peer?.id || peer?.address || peerId || 'unknown';
             debug(`lastBlock request failed: ${peerName}:`, error?.message ?? error);
+            await this.#recordPeerFailure(peerId, `lastBlock request failed: ${error?.message ?? error}`);
             return;
         }
+        // CRITICAL: Validate the peer's claimed block height is not unreasonably ahead of our local chain
+        // This prevents Byzantine nodes from claiming a fake chain length to steer our sync
         const localBlock = await this.lastBlock;
+        const MAX_SYNC_AHEAD = 100_000;
+        if (lastBlock?.index > (localBlock?.index ?? 0) + MAX_SYNC_AHEAD) {
+            const peerName = peer?.peerId || peer?.id || peer?.address || peerId || 'unknown';
+            debug(`Peer ${peerName} claims unreasonable block height ${lastBlock.index} (local: ${localBlock?.index ?? 0})`);
+            await this.#recordPeerFailure(peerId, `unreasonable lastBlock index: ${lastBlock.index}`);
+            return;
+        }
         if (!lastBlock || !lastBlock.hash || lastBlock.hash === '0x0') {
             debug(`peer has no lastBlock: ${peerId}`);
             return;
@@ -6443,14 +6907,20 @@ class Chain extends VersionControl {
                             console.log(e);
                         }
                     }
-                    if (knownBlocksResponse.blocks)
-                        for (const hash of knownBlocksResponse.blocks) {
-                            this.wantList.push(hash);
+                    const MAX_WANTLIST_SIZE = 1000;
+                    if (knownBlocksResponse.blocks) {
+                        const remaining = MAX_WANTLIST_SIZE - this.wantList.length;
+                        if (remaining > 0) {
+                            for (const hash of knownBlocksResponse.blocks.slice(0, remaining)) {
+                                this.wantList.push(hash);
+                            }
                         }
+                    }
                 }
                 catch (error) {
                     const peerName = peer?.peerId || peer?.id || peer?.address || peerId || 'unknown';
                     debug(`knownBlocks request failed: ${peerName}:`, error?.message ?? error);
+                    await this.#recordPeerFailure(peerId, `knownBlocks request failed: ${error?.message ?? error}`);
                     return;
                 }
             }
@@ -6493,6 +6963,7 @@ class Chain extends VersionControl {
         catch (error) {
             const peerName = peer?.peerId || peer?.id || peer?.address || peerId || 'unknown';
             debug(`stateInfo/syncChain failed: ${peerName}:`, error?.message ?? error);
+            await this.#recordPeerFailure(peerId, `stateInfo/syncChain failed: ${error?.message ?? error}`);
             return;
         }
     }
@@ -6529,26 +7000,55 @@ class Chain extends VersionControl {
         const receivedEncoded = block instanceof BlockMessage ? block.encoded : block;
         const blockMessage = await new BlockMessage(block);
         const hash = await blockMessage.hash();
-        // Verify data integrity: re-encode should produce the same bytes
-        const canonicalEncoded = blockMessage.encoded;
-        if (receivedEncoded.length === canonicalEncoded.length) {
-            let mismatch = false;
-            for (let i = 0; i < receivedEncoded.length; i++) {
-                if (receivedEncoded[i] !== canonicalEncoded[i]) {
-                    mismatch = true;
-                    break;
-                }
+        // CRITICAL: VALIDATE BEFORE TOUCHING STATE
+        // 1. Check for duplicate blocks at same height
+        const blockIndex = Number(blockMessage.decoded.index);
+        const existingBlockAtHeight = this.#blocks[blockIndex];
+        if (existingBlockAtHeight) {
+            if (existingBlockAtHeight.hash !== hash) {
+                console.error(`[CONSENSUS ALERT] Conflicting blocks at height ${blockIndex}:`);
+                console.error(`  Local:  ${existingBlockAtHeight.hash}`);
+                console.error(`  Remote: ${hash}`);
+                throw new Error(`Block conflict detected at index ${blockIndex}`);
             }
-            if (mismatch) {
-                console.warn(`[chain] ⚠️  Block data corrupted in transit: encoded bytes don't match canonical form for block #${blockMessage.decoded.index}`);
+            // Already have this exact block, skip
+            debug(`Block already in store: ${hash}`);
+            return;
+        }
+        // 2. Verify previous hash chain integrity
+        if (blockIndex > 0) {
+            const previousBlockInfo = this.#blocks[blockIndex - 1];
+            if (!previousBlockInfo) {
+                throw new Error(`Missing parent block at index ${blockIndex - 1}`);
             }
-            else {
-                console.log(`[chain] ✅ Block data integrity verified via codec: ${hash}`);
+            if (previousBlockInfo.hash !== blockMessage.decoded.previousHash) {
+                throw new Error(`previousHash mismatch at index ${blockIndex}: ` +
+                    `expected ${previousBlockInfo.hash}, got ${blockMessage.decoded.previousHash}`);
             }
         }
-        else {
-            console.warn(`[chain] ⚠️  Block data size mismatch: received ${receivedEncoded.length} bytes but canonical is ${canonicalEncoded.length} bytes for block #${blockMessage.decoded.index}`);
+        else if (blockMessage.decoded.previousHash !== '0x0') {
+            throw new Error(`Genesis block (index 0) must have previousHash='0x0'`);
+        }
+        // 3. Verify data integrity
+        const canonicalEncoded = blockMessage.encoded;
+        const byteLengthMatch = receivedEncoded.length === canonicalEncoded.length;
+        if (!byteLengthMatch) {
+            throw new Error(`[FATAL] Block data size mismatch: received ${receivedEncoded.length} bytes ` +
+                `but canonical encoding is ${canonicalEncoded.length} bytes for block #${blockMessage.decoded.index}`);
+        }
+        let mismatch = false;
+        for (let i = 0; i < receivedEncoded.length; i++) {
+            if (receivedEncoded[i] !== canonicalEncoded[i]) {
+                mismatch = true;
+                break;
+            }
         }
+        if (mismatch) {
+            throw new Error(`[FATAL] Block data corrupted in transit for block #${blockIndex} hash ${hash}`);
+        }
+        console.log(`[chain] ✅ Block data integrity verified: ${hash}`);
+        this.#validateBlockValidators(blockMessage);
+        // NOW SAFE TO PROCEED with transaction processing
         const transactions = await Promise.all(blockMessage.decoded.transactions
             // @ts-ignore
             .map(async (hash) => {
@@ -6557,24 +7057,34 @@ class Chain extends VersionControl {
             return new TransactionMessage(data);
         }));
         await globalThis.blockStore.put(hash, blockMessage.encoded);
+        // Cache block for conflict detection
+        this.#blocks[blockIndex] = {
+            hash,
+            ...blockMessage.decoded
+        };
         debug(`added block: ${hash}`);
         let promises = [];
         let contracts = [];
-        const normalTransactions = [];
-        const priorityransactions = [];
-        for (const transaction of transactions) {
+        // Combine and sort all transactions deterministically
+        const allTransactions = transactions.sort((a, b) => {
+            // Primary: by priority (true first)
+            if (a.decoded.priority !== b.decoded.priority) {
+                return (b.decoded.priority ? 1 : 0) - (a.decoded.priority ? 1 : 0);
+            }
+            // Secondary: by nonce
+            const nonceDiff = (a.decoded?.nonce ?? 0) - (b.decoded?.nonce ?? 0);
+            if (nonceDiff !== 0)
+                return nonceDiff;
+            // Tertiary: in stable order (insertion order preserved)
+            return 0;
+        });
+        // Execute sequentially (NOT concurrently) to ensure deterministic state
+        for (const transaction of allTransactions) {
             if (!contracts.includes(transaction.decoded.to)) {
                 contracts.push(transaction.decoded.to);
             }
-            if (transaction.decoded.priority)
-                priorityransactions.push(transaction);
-            else
-                normalTransactions.push(transaction);
-        }
-        for (const transaction of priorityransactions.sort((a, b) => a.decoded.nonce - b.decoded.nonce)) {
             await this.#handleTransaction(transaction, []);
         }
-        await Promise.all(normalTransactions.map((transaction) => this.#handleTransaction(transaction, [])));
         // for (let transaction of transactionsMessages) {
         //   // await transactionStore.put(transaction.hash, transaction.encoded)
         //   if (!contracts.includes(transaction.to)) {
@@ -6599,6 +7109,15 @@ class Chain extends VersionControl {
             await Promise.all(Object.entries(noncesByAddress).map(([from, nonce]) => globalThis.accountsStore.put(from, String(nonce))));
             if ((await this.lastBlock).index < Number(blockMessage.decoded.index)) {
                 await this.machine.addLoadedBlock({ ...blockMessage.decoded, loaded: true, hash: await blockMessage.hash() });
+                // Record validator snapshot at this block height for future consensus queries
+                try {
+                    await this.call(addresses.validators, 'recordValidatorSnapshot', [blockMessage.decoded.index]);
+                }
+                catch (snapshotError) {
+                    debug(`failed to record validator snapshot: ${snapshotError?.message ?? snapshotError}`);
+                }
+                // Check if this block crosses epoch boundary and handle transition
+                await this.#handleEpochBoundary(Number(blockMessage.decoded.index));
                 await this.updateState(blockMessage);
             }
             globalThis.pubsub.publish('block-processed', blockMessage.decoded);
@@ -6690,23 +7209,31 @@ class Chain extends VersionControl {
             timestamp,
             previousHash: '',
             reward: BigInt(150),
-            index: 0
+            index: 0,
+            producer: '',
+            producerProof: '',
+            protocolVersion: this.version
         };
         const latestTransactions = await this.machine.latestTransactions();
         // exclude failing tx
         transactions = await this.promiseTransactions(transactions);
-        const normalTransactions = [];
-        const priorityransactions = [];
-        for (const transaction of transactions) {
-            if (transaction.decoded.priority)
-                priorityransactions.push(transaction);
-            else
-                normalTransactions.push(transaction);
-        }
-        for (const transaction of priorityransactions.sort((a, b) => a.decoded.nonce - b.decoded.nonce)) {
+        // Combine priority and normal transactions, then sort deterministically
+        const allTransactions = transactions.sort((a, b) => {
+            // Primary: by priority (true first)
+            if (a.decoded.priority !== b.decoded.priority) {
+                return (b.decoded.priority ? 1 : 0) - (a.decoded.priority ? 1 : 0);
+            }
+            // Secondary: by nonce
+            const nonceDiff = (a.decoded?.nonce ?? 0) - (b.decoded?.nonce ?? 0);
+            if (nonceDiff !== 0)
+                return nonceDiff;
+            // Tertiary: in stable order (insertion order preserved)
+            return 0;
+        });
+        // Execute sequentially (NOT concurrently) to ensure deterministic state
+        for (const transaction of allTransactions) {
             await this.#handleTransaction(transaction, latestTransactions, block);
         }
-        await Promise.all(normalTransactions.map((transaction) => this.#handleTransaction(transaction, latestTransactions, block)));
         // don't add empty block
         if (block.transactions.length === 0)
             return;
@@ -6724,7 +7251,7 @@ class Chain extends VersionControl {
         }
         for (const validator of validators) {
             const peer = peers[validator];
-            if (peer && peer.connected && peer.version === this.version) {
+            if (peer && peer.connected && this.isVersionCompatible(peer.version)) {
                 let data = await new BWRequestMessage();
                 const node = await globalThis.peernet.prepareMessage(data.encoded);
                 try {
@@ -6764,26 +7291,54 @@ class Chain extends VersionControl {
         // block.timestamp = Date.now()
         // block.reward = block.reward.toString()
         // block.fees = block.fees.toString()
+        // CRITICAL FIX: Sort validators deterministically to avoid encoding divergence
+        // Use canonical validator set from contract, sorted by address
+        const canonicalValidators = (await this.staticCall(addresses.validators, 'validators'));
+        const sortedValidators = [...canonicalValidators].sort();
+        // Apply reward to all canonical validators (deterministic)
+        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);
             }));
+            // Set producer to current account
+            block.producer = globalThis.peernet.selectedAccount || '';
+            // Sign block hash to authenticate producer (producer must be the proposer)
+            if (block.producer && this.keypair) {
+                const blockHashInput = JSON.stringify({
+                    index: block.index,
+                    previousHash: block.previousHash,
+                    timestamp: block.timestamp,
+                    validators: block.validators.map((v) => v.address).sort()
+                });
+                block.producerProof = await signTransaction(blockHashInput, this.keypair);
+            }
             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}`);
-            // Publish canonical encoded form via codec interface
-            console.log(`[chain] 📤 Publishing block #${block.index} | hash: ${hash} | encoded bytes: ${blockMessage.encoded.length}`);
+            // Phase 2: announce proposal for consensus voting instead of direct add-block
+            console.log(`[consensus] 📤 Proposing block #${block.index} | hash: ${hash} | round: ${this.#consensusRound}`);
+            const proposalPayload = new TextEncoder().encode(JSON.stringify({
+                blockHash: hash,
+                index: block.index,
+                round: this.#consensusRound,
+                from: peernet.selectedAccount
+            }));
             try {
-                globalThis.peernet.publish('add-block', blockMessage.encoded);
+                globalThis.peernet.publish('consensus:propose', proposalPayload);
             }
             catch (publishError) {
-                debug('peernet publish failed: add-block', publishError?.message ?? publishError);
+                debug('peernet publish failed: consensus:propose', publishError?.message ?? publishError);
             }
-            globalThis.pubsub.publish('add-block', blockMessage.encoded);
+            // Proposer casts their own prevote immediately
+            await this.#castVote('prevote', hash, block.index, this.#consensusRound);
         }
         catch (error) {
             console.log(error);