@leofcoin/chain 1.9.2 → 1.9.4

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-BTdMMS4w.js';
+import { t as toBase58, T as TransactionMessage, C as ContractMessage, R as RawTransactionMessage, B as BlockMessage, L as LastBlockMessage, P as PROTOCOL_VERSION, a as REACHED_ONE_ZERO_ZERO, b as PrevoteMessage, c as PrecommitMessage, d as ProposalMessage, e as BWMessage, S as StateMessage, f as BWRequestMessage } from './constants-D_XqG46B.js';
 import { log } from 'console';
 import { log as log$1 } from 'node:console';
 
@@ -3912,11 +3912,25 @@ class Transaction extends Protocol {
         return Number(nonce);
     }
     async validateNonce(address, nonce) {
-        const previousNonce = await this.getNonce(address);
-        if (previousNonce > nonce)
-            throw new Error(`a transaction with a higher nonce already exists`);
-        if (previousNonce === nonce)
+        // Compare only against the COMMITTED nonce (accountsStore), not the pool max.
+        // The pool may hold many future nonces from batch sends — rejecting lower nonces
+        // because a higher one is already queued would break concurrent batch submission.
+        let committedNonce;
+        try {
+            if (await globalThis.accountsStore.has(address)) {
+                const raw = await globalThis.accountsStore.get(address);
+                committedNonce = Number(new TextDecoder().decode(raw));
+            }
+            else {
+                committedNonce = await this.#getNonceFallback(address);
+            }
+        }
+        catch {
+            committedNonce = 0;
+        }
+        if (committedNonce >= nonce)
             throw new Error(`a transaction with the same nonce already exists`);
+        // Only reject exact duplicates already in the pool (not "higher nonce" rejections)
         let transactions = await globalThis.transactionPoolStore.values();
         transactions = await this.promiseTransactions(transactions);
         transactions = transactions.filter((tx) => tx.decoded.from === address);
@@ -5041,11 +5055,6 @@ class Jobber {
     }
 }
 
-utils.addCodec({
-    name: 'last-block-message',
-    codec: 0x6c626d,
-    hashAlg: 'keccak-256'
-});
 const debug$1 = createDebugger('leofcoin/state');
 class State extends Contract {
     #resolveErrored;
@@ -5607,6 +5616,8 @@ class State extends Contract {
     }
     async #getLatestBlock() {
         let promises = [];
+        const connectedPeers = Object.values(globalThis.peernet.connections || {}).filter((peer) => peer.connected);
+        let compatiblePeerCount = 0;
         let data = await new globalThis.peernet.protos['peernet-request']({
             request: 'lastBlock'
         });
@@ -5614,15 +5625,8 @@ class State extends Contract {
         for (const id in globalThis.peernet.connections) {
             // @ts-ignore
             const peer = globalThis.peernet.connections[id];
-            // 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()) {
+            if (peer.connected && this.isVersionCompatible(peer.version)) {
+                compatiblePeerCount += 1;
                 const task = async () => {
                     try {
                         const result = await peer.request(node.encoded);
@@ -5639,9 +5643,15 @@ class State extends Contract {
                 promises.push(task());
             }
         }
+        if (connectedPeers.length > 0 && compatiblePeerCount === 0) {
+            throw new ResolveError(`latestBlock: no compatible peers found for local version ${this.version} among ${connectedPeers.length} connected peers`);
+        }
         // @ts-ignore
         console.log({ promises });
         promises = (await this.promiseRequests(promises));
+        if (compatiblePeerCount > 0 && promises.length === 0) {
+            throw new ResolveError('latestBlock: no responses from compatible peers');
+        }
         console.log({ promises });
         let latest = { index: 0, hash: '0x0', previousHash: '0x0' };
         promises = promises.sort((a, b) => b.index - a.index);
@@ -5656,15 +5666,7 @@ class State extends Contract {
                 throw new Error('invalid block @getLatestBlock');
             latest = { ...message.decoded, hash };
             const peer = promises[0].peer;
-            // 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()) {
+            if (peer.connected && this.isVersionCompatible(peer.version)) {
                 let data = await new globalThis.peernet.protos['peernet-request']({
                     request: 'knownBlocks'
                 });
@@ -5812,7 +5814,7 @@ class State extends Contract {
         if (this.#chainSyncing)
             return false;
         // Check if we have any connected peers with the same version
-        const compatiblePeers = Object.values(globalThis.peernet.connections || {}).filter((peer) => peer.connected && peer.version === this.version);
+        const compatiblePeers = Object.values(globalThis.peernet.connections || {}).filter((peer) => peer.connected && this.isVersionCompatible(peer.version));
         if (compatiblePeers.length === 0) {
             debug$1('No compatible peers available for sync');
             return false;
@@ -5828,7 +5830,7 @@ class State extends Contract {
     async #waitForPeers(timeoutMs = 30000) {
         return new Promise((resolve) => {
             const checkPeers = () => {
-                const peers = Object.values(globalThis.peernet.connections || {}).filter((peer) => peer.connected && peer.version === this.version);
+                const peers = Object.values(globalThis.peernet.connections || {}).filter((peer) => peer.connected && this.isVersionCompatible(peer.version));
                 if (peers.length > 0) {
                     resolve(true);
                 }
@@ -6147,7 +6149,7 @@ class ConnectionMonitor {
                 const networkName = globalThis.peernet?.network;
                 if (networkName && typeof networkName === 'string') {
                     // Try to import network config
-                    const { default: networks } = await import('./constants-BTdMMS4w.js').then(function (n) { return n.n; });
+                    const { default: networks } = await import('./constants-D_XqG46B.js').then(function (n) { return n.n; });
                     const [mainKey, subKey] = networkName.split(':');
                     const networkConfig = networks?.[mainKey]?.[subKey];
                     if (networkConfig?.stars && Array.isArray(networkConfig.stars)) {
@@ -6239,16 +6241,6 @@ class ConnectionMonitor {
     }
 }
 
-utils.addCodec({
-    name: 'last-block-message',
-    codec: 0x6c626d,
-    hashAlg: 'keccak-256'
-});
-utils.addCodec({
-    name: 'last-block-request-message',
-    codec: 0x6c62726d,
-    hashAlg: 'keccak-256'
-});
 const debug = createDebugger('leofcoin/chain');
 // check if browser or local
 class Chain extends VersionControl {
@@ -6342,7 +6334,10 @@ class Chain extends VersionControl {
                 return;
             this.#castedVotes.add(voteKey);
             const from = peernet.selectedAccount;
-            const payload = new TextEncoder().encode(JSON.stringify({ blockHash, index, round, from }));
+            const voteData = { blockHash, index: BigInt(index), round: BigInt(round), from };
+            const Message = type === 'prevote' ? PrevoteMessage : PrecommitMessage;
+            const message = new Message(voteData);
+            const payload = message.encoded;
             try {
                 globalThis.peernet.publish(`consensus:${type}`, payload);
             }
@@ -6357,16 +6352,17 @@ class Chain extends VersionControl {
          */
         this.#handleProposal = async (payload) => {
             try {
-                const msg = JSON.parse(new TextDecoder().decode(payload));
+                const message = new ProposalMessage(payload);
+                const msg = message.decoded;
                 const { blockHash, index, round, from } = msg;
-                const validators = await this.#getConsensusValidators(index);
-                const expectedProposerIdx = (index + round) % validators.length;
+                const validators = await this.#getConsensusValidators(Number(index));
+                const expectedProposerIdx = Number((index + round) % BigInt(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;
+                const localIndex = localBlock?.index !== undefined ? localBlock.index : -1n;
                 if (index <= localIndex) {
                     debug(`[consensus] Ignoring stale proposal at height ${index} (local: ${localIndex})`);
                     return;
@@ -6385,13 +6381,13 @@ class Chain extends VersionControl {
                     debug(`[consensus] Cannot fetch proposed block ${blockHash}:`, e?.message);
                     return;
                 }
-                this.#consensusRound = round;
+                this.#consensusRound = Number(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);
+                    await this.#castVote('prevote', blockHash, Number(index), Number(round));
                 }
             }
             catch (e) {
@@ -6404,13 +6400,14 @@ class Chain extends VersionControl {
          */
         this.#handlePrevote = async (payload) => {
             try {
-                const msg = JSON.parse(new TextDecoder().decode(payload));
+                const message = new PrevoteMessage(payload);
+                const msg = message.decoded;
                 const { blockHash, index, round, from } = msg;
-                const validators = await this.#getConsensusValidators(index);
+                const validators = await this.#getConsensusValidators(Number(index));
                 if (!validators.includes(from))
                     return;
                 const localBlock = await this.lastBlock;
-                const localIndex = localBlock?.index !== undefined ? Number(localBlock.index) : -1;
+                const localIndex = localBlock?.index !== undefined ? localBlock.index : -1n;
                 if (index <= localIndex)
                     return;
                 const voteKey = `${index}:${round}:${blockHash}`;
@@ -6423,7 +6420,7 @@ class Chain extends VersionControl {
                 if (voteCount >= threshold &&
                     validators.includes(peernet.selectedAccount) &&
                     !this.#isJailed(peernet.selectedAccount)) {
-                    await this.#castVote('precommit', blockHash, index, round);
+                    await this.#castVote('precommit', blockHash, Number(index), Number(round));
                 }
             }
             catch (e) {
@@ -6437,12 +6434,13 @@ class Chain extends VersionControl {
          */
         this.#handlePrecommit = async (payload) => {
             try {
-                const msg = JSON.parse(new TextDecoder().decode(payload));
+                const message = new PrecommitMessage(payload);
+                const msg = message.decoded;
                 const { blockHash, index, round, from } = msg;
-                const validators = await this.#getConsensusValidators(index);
+                const validators = await this.#getConsensusValidators(Number(index));
                 if (!validators.includes(from))
                     return;
-                if (index <= this.#committedHeight)
+                if (index <= BigInt(this.#committedHeight))
                     return;
                 const voteKey = `${index}:${round}:${blockHash}`;
                 if (!this.#precommits.has(voteKey))
@@ -6451,27 +6449,27 @@ class Chain extends VersionControl {
                 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;
+                if (voteCount >= threshold && index > BigInt(this.#committedHeight)) {
+                    this.#committedHeight = Number(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)
+                        if (BigInt(key.split(':')[0]) <= index)
                             this.#prevotes.delete(key);
                     }
                     for (const key of [...this.#precommits.keys()]) {
-                        if (Number(key.split(':')[0]) <= index)
+                        if (BigInt(key.split(':')[0]) <= index)
                             this.#precommits.delete(key);
                     }
                     for (const key of [...this.#castedVotes]) {
-                        if (Number(key.split(':')[1]) <= index)
+                        if (BigInt(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;
+                    const currentIndex = currentBlock?.index !== undefined ? currentBlock.index : -1n;
                     if (index > currentIndex) {
                         debug(`[consensus] ✅ Committing block ${blockHash} at height ${index}`);
                         try {
@@ -6744,7 +6742,9 @@ class Chain extends VersionControl {
         await globalThis.peernet.addRequestHandler('transactionPool', this.#transactionPoolHandler.bind(this));
         await globalThis.peernet.addRequestHandler('version', this.#versionHandler.bind(this));
         await globalThis.peernet.addRequestHandler('stateInfo', () => {
-            return new globalThis.peernet.protos['peernet-response']({ response: this.machine.states.info });
+            return new globalThis.peernet.protos['peernet-response']({
+                response: new StateMessage(this.machine.states.info).encoded
+            });
         });
         globalThis.peernet.subscribe('add-block', this.#addBlock.bind(this));
         globalThis.peernet.subscribe('invalid-transaction', this.#invalidTransaction.bind(this));
@@ -6832,13 +6832,8 @@ class Chain extends VersionControl {
     async getPeerTransactionPool(peer) {
         let transactionsInPool = await this.#makeRequest(peer, 'transactionPool');
         if (transactionsInPool instanceof Uint8Array) {
-            try {
-                const text = new TextDecoder().decode(transactionsInPool);
-                transactionsInPool = JSON.parse(text);
-            }
-            catch (e) {
-                return [];
-            }
+            debug('transactionPool response must be decoded array payload');
+            return [];
         }
         if (!Array.isArray(transactionsInPool))
             return [];
@@ -6862,9 +6857,41 @@ class Chain extends VersionControl {
     async #peerConnected(peerId) {
         debug(`peer connected: ${peerId}`);
         const peer = peernet.getConnection(peerId);
+        if (!peer) {
+            debug(`peer not found: ${peerId}`);
+            return;
+        }
+        if (!peer.version) {
+            try {
+                let versionResponse = await this.#makeRequest(peer, 'version');
+                if (versionResponse instanceof Uint8Array) {
+                    versionResponse = new TextDecoder().decode(versionResponse);
+                }
+                if (typeof versionResponse === 'string') {
+                    peer.version = versionResponse;
+                }
+                else if (versionResponse &&
+                    typeof versionResponse === 'object' &&
+                    typeof versionResponse.version === 'string') {
+                    peer.version = versionResponse.version;
+                }
+                if (!peer.version || typeof peer.version !== 'string') {
+                    const reason = `invalid version response from peer ${peerId}`;
+                    debug(reason);
+                    await this.#recordPeerFailure(peerId, reason);
+                    return;
+                }
+            }
+            catch (error) {
+                debug(`failed to request version from peer ${peerId}:`, error?.message ?? error);
+                return;
+            }
+        }
         debug(`peer connected with version ${peer.version}`);
         if (!this.isVersionCompatible(peer.version)) {
-            debug(`versions don't match`);
+            const mismatchReason = `incompatible peer version ${peer.version} (local: ${this.version})`;
+            console.error(`[chain] ${mismatchReason}`);
+            await this.#recordPeerFailure(peerId, mismatchReason);
             return;
         }
         let lastBlock;
@@ -6884,7 +6911,7 @@ class Chain extends VersionControl {
         // 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) {
+        if (lastBlock?.index > BigInt(localBlock?.index ?? 0) + BigInt(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}`);
@@ -6900,15 +6927,13 @@ class Chain extends VersionControl {
                 try {
                     let knownBlocksResponse = await this.#makeRequest(peer, 'knownBlocks');
                     if (knownBlocksResponse instanceof Uint8Array) {
-                        try {
-                            knownBlocksResponse = JSON.parse(new TextDecoder().decode(knownBlocksResponse));
-                        }
-                        catch (e) {
-                            console.log(e);
-                        }
+                        const reason = `knownBlocks must be object response, got raw bytes from ${peerId}`;
+                        debug(reason);
+                        await this.#recordPeerFailure(peerId, reason);
+                        return;
                     }
                     const MAX_WANTLIST_SIZE = 1000;
-                    if (knownBlocksResponse.blocks) {
+                    if (knownBlocksResponse && Array.isArray(knownBlocksResponse.blocks)) {
                         const remaining = MAX_WANTLIST_SIZE - this.wantList.length;
                         if (remaining > 0) {
                             for (const hash of knownBlocksResponse.blocks.slice(0, remaining)) {
@@ -6950,12 +6975,7 @@ class Chain extends VersionControl {
         try {
             let stateInfo = await this.#makeRequest(peer, 'stateInfo');
             if (stateInfo instanceof Uint8Array) {
-                try {
-                    stateInfo = JSON.parse(new TextDecoder().decode(stateInfo));
-                }
-                catch (e) {
-                    console.log(e);
-                }
+                stateInfo = new StateMessage(stateInfo).decoded;
             }
             await this.syncChain(lastBlock);
             this.machine.states.info = stateInfo;
@@ -6973,7 +6993,7 @@ class Chain extends VersionControl {
         return new globalThis.peernet.protos['peernet-response']({ response: pool });
     }
     async #versionHandler() {
-        return new globalThis.peernet.protos['peernet-response']({ response: { version: this.version } });
+        return new globalThis.peernet.protos['peernet-response']({ response: this.version });
     }
     async #executeTransaction({ hash, from, to, method, params, nonce }) {
         try {
@@ -7325,12 +7345,14 @@ class Chain extends VersionControl {
             debug(`created block: ${hash} @${block.index}`);
             // 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({
+            const proposalData = {
                 blockHash: hash,
-                index: block.index,
-                round: this.#consensusRound,
+                index: BigInt(block.index),
+                round: BigInt(this.#consensusRound),
                 from: peernet.selectedAccount
-            }));
+            };
+            const proposalMessage = new ProposalMessage(proposalData);
+            const proposalPayload = proposalMessage.encoded;
             try {
                 globalThis.peernet.publish('consensus:propose', proposalPayload);
             }