@leofcoin/chain 1.8.4 → 1.8.6

package/exports/chain.js

@@ -7,9 +7,11 @@ 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 { log } from 'console';
+import { log as log$1 } from 'node:console';
 
 const limit = 1800;
-const transactionLimit = 1000;
+const transactionLimit = 2500;
 const requestTimeout = 30_000;
 const syncTimeout = 30_000;
 class Protocol {
@@ -90,12 +92,16 @@ class Transaction extends Protocol {
         // @ts-ignore
         if (this.lastBlock?.hash && transactions.length === 0 && this.lastBlock.hash !== '0x0') {
             // @ts-ignore
-            let block = await peernet.get(this.lastBlock.hash, 'block');
+            let block;
+            try {
+                block = await globalThis.peernet.get(this.lastBlock.hash, 'block');
+            }
+            catch (error) {
+                block = undefined;
+            }
+            if (block === undefined)
+                return []; // Fallback if block unavailable
             block = await new BlockMessage(block);
-            // for (let tx of block.decoded?.transactions) {
-            //   tx = await peernet.get(tx, 'transaction')
-            //   transactions.push(new TransactionMessage(tx))
-            // }
             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);
@@ -105,8 +111,13 @@ class Transaction extends Protocol {
         }
         if (transactions.length === 0)
             return 0;
-        transactions = transactions.sort((a, b) => a.timestamp - b.timestamp);
-        return transactions[transactions.length - 1].nonce;
+        // Optimize: find max nonce instead of sorting entire array
+        let maxNonce = 0;
+        for (const tx of transactions) {
+            if (tx.nonce > maxNonce)
+                maxNonce = tx.nonce;
+        }
+        return maxNonce;
     }
     /**
      * Get amount of transactions by address
@@ -114,6 +125,8 @@ class Transaction extends Protocol {
      * @returns {Number} nonce
      */
     async getNonce(address) {
+        // DO NOT use nonce cache here - multiple parallel calls could create race conditions
+        // Instead, optimize the store queries and pool filtering
         try {
             if (!(await globalThis.accountsStore.has(address))) {
                 const nonce = await this.#getNonceFallback(address);
@@ -215,6 +228,235 @@ class Transaction extends Protocol {
     }
 }
 
+/**
+ * Utility functions for contract inheritance and code reuse
+ */
+/**
+ * Check if a class is derived from another class
+ * @param derivedClass The class to check
+ * @param baseClass The potential base class
+ * @returns true if derivedClass extends baseClass
+ */
+const isDerivedFrom = (derivedClass, baseClass) => {
+    if (!derivedClass || !baseClass)
+        return false;
+    let proto = Object.getPrototypeOf(derivedClass);
+    while (proto) {
+        if (proto === baseClass)
+            return true;
+        proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+};
+/**
+ * Parse contract inheritance information from contract code
+ * @param contractCode The contract code to parse
+ * @returns Information about the contract's inheritance
+ */
+const parseContractInheritance = (contractCode) => {
+    const classMatch = contractCode.match(/class\s+(\w+)(?:\s+extends\s+(\w+))?/);
+    if (!classMatch) {
+        return { className: null, baseClass: null, hasInheritance: false };
+    }
+    return {
+        className: classMatch[1],
+        baseClass: classMatch[2] || null,
+        hasInheritance: !!classMatch[2]
+    };
+};
+
+/**
+ * Registry for managing base contracts and contract inheritance
+ */
+class ContractRegistry {
+    constructor() {
+        this.baseContracts = new Map(); // hash -> ContractMessage
+        this.contractNames = new Map(); // name -> hash
+        this.contractDependencies = new Map();
+    }
+    /**
+     * Register a base contract that can be reused
+     * Uses the contract code hash as the identifier and registers the name in nameService
+     * @param name The name to register in nameService
+     * @param message The contract message
+     * @returns The contract hash
+     */
+    async registerBaseContract(name, message) {
+        const hash = await message.hash();
+        // Store by hash (the actual identifier)
+        this.baseContracts.set(hash, message);
+        this.contractNames.set(name, hash);
+        // Store in contract store
+        if (globalThis.contractStore) {
+            await globalThis.contractStore.put(hash, message.encoded);
+        }
+        return hash;
+    }
+    /**
+     * Register a name for a contract hash in the nameService
+     * @param name The name to register
+     * @param hash The contract hash
+     * @param chain The chain instance (for making transactions)
+     * @param signer The wallet to sign the transaction
+     */
+    async registerNameInNameService(name, hash, chain, signer) {
+        // Register the name -> hash mapping in the on-chain nameService contract
+        ({
+            from: await signer.address,
+            to: addresses.nameService});
+        // This would need to be signed and sent through the chain
+        // Implementation depends on your chain's transaction flow
+    }
+    /**
+     * Get a base contract by name
+     * First checks local registry, then queries nameService if available
+     * @param name The name of the base contract
+     * @returns The contract message or undefined
+     */
+    getBaseContract(name) {
+        // Check local name mapping
+        const hash = this.contractNames.get(name);
+        if (hash) {
+            return this.baseContracts.get(hash);
+        }
+        // If not found locally, try to lookup in nameService
+        // This would require access to the chain instance to call nameService
+        return undefined;
+    }
+    /**
+     * Get a base contract by hash
+     * @param hash The hash of the contract
+     * @returns The contract message or undefined
+     */
+    getBaseContractByHash(hash) {
+        return this.baseContracts.get(hash);
+    }
+    /**
+     * Resolve a name to a hash (first local, then nameService)
+     * @param name The contract name
+     * @returns The contract hash or undefined
+     */
+    resolveNameToHash(name) {
+        return this.contractNames.get(name);
+    }
+    /**
+     * Register contract dependencies (inheritance chain)
+     * @param contractHash The hash of the contract
+     * @param dependencies Array of base contract hashes this contract depends on
+     */
+    registerDependencies(contractHash, dependencies) {
+        this.contractDependencies.set(contractHash, dependencies);
+    }
+    /**
+     * Get all dependencies for a contract
+     * @param contractHash The hash of the contract
+     * @returns Array of dependency hashes
+     */
+    getDependencies(contractHash) {
+        return this.contractDependencies.get(contractHash) || [];
+    }
+    /**
+     * Check if all dependencies for a contract are available
+     * @param contractHash The hash of the contract
+     * @returns true if all dependencies are available
+     */
+    async areDependenciesAvailable(contractHash) {
+        const dependencies = this.getDependencies(contractHash);
+        if (dependencies.length === 0)
+            return true;
+        for (const depHash of dependencies) {
+            try {
+                if (globalThis.contractStore) {
+                    await globalThis.contractStore.get(depHash);
+                }
+                else {
+                    return false;
+                }
+            }
+            catch {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Get all registered contract hashes
+     * @returns Array of contract hashes
+     */
+    getBaseContractHashes() {
+        return Array.from(this.baseContracts.keys());
+    }
+    /**
+     * Get hash for a registered name
+     * @param name The contract name
+     * @returns The hash or undefined
+     */
+    getHashForName(name) {
+        return this.contractNames.get(name);
+    }
+    /**
+     * Analyze contract code and extract inheritance information
+     * @param contractCode The contract code to analyze
+     * @returns Inheritance information
+     */
+    analyzeContract(contractCode) {
+        return parseContractInheritance(contractCode);
+    }
+    /**
+     * Build a complete contract by combining base contracts
+     * @param contractCode The derived contract code
+     * @param baseContractIdentifiers Names or hashes of base contracts to include
+     * @returns Combined contract code
+     */
+    async buildContract(contractCode, baseContractIdentifiers = []) {
+        let combinedCode = '';
+        // Add base contracts first
+        for (const identifier of baseContractIdentifiers) {
+            // Try as name first, then as hash
+            let baseContract = await this.getBaseContract(identifier);
+            if (!baseContract) {
+                baseContract = this.getBaseContractByHash(identifier);
+            }
+            if (baseContract) {
+                const decoded = baseContract.decoded;
+                combinedCode += `// Base contract: ${identifier}\n`;
+                combinedCode += decoded.contract + '\n\n';
+            }
+        }
+        // Add the derived contract
+        combinedCode += contractCode;
+        return combinedCode;
+    }
+    /**
+     * Clear all registered contracts
+     */
+    clear() {
+        this.baseContracts.clear();
+        this.contractDependencies.clear();
+    }
+    /**
+     * Get all registered base contract names
+     * @returns Array of base contract names
+     */
+    getBaseContractNames() {
+        return Array.from(this.contractNames.keys());
+    }
+    /**
+     * Get name for a hash if registered
+     * @param hash The contract hash
+     * @returns The name or undefined
+     */
+    getNameForHash(hash) {
+        for (const [name, h] of this.contractNames.entries()) {
+            if (h === hash)
+                return name;
+        }
+        return undefined;
+    }
+}
+// Export a singleton instance
+const contractRegistry = new ContractRegistry();
+
 /**
  * @extends {Transaction}
  */
@@ -253,6 +495,58 @@ class Contract extends Transaction {
         const message = await createContractMessage(await signer.address, contract, constructorParameters);
         return this.deployContractMessage(signer, message);
     }
+    /**
+     * Register a base contract for reuse by other contracts
+     * The contract is stored by its hash, enabling inheritance and code reuse
+     * @param {String} name The name to register for this contract
+     * @param {String} contract The contract code
+     * @param {Array} constructorParameters Constructor parameters
+     * @returns {Promise<string>} The contract hash
+     */
+    async registerBaseContract(name, contract, constructorParameters = []) {
+        const creator = addresses.contractFactory;
+        // Base contracts are hashed without constructor parameters
+        const message = await createContractMessage(creator, contract, []);
+        const hash = await contractRegistry.registerBaseContract(name, message);
+        // Store the contract by its hash
+        try {
+            await globalThis.contractStore.put(hash, message.encoded);
+        }
+        catch (error) {
+            throw error;
+        }
+        return hash;
+    }
+    /**
+     * Deploy a contract with optional base contracts for inheritance
+     * @param {MultiWallet} signer The wallet to sign with
+     * @param {String} contract The contract code
+     * @param {Array} constructorParameters Constructor parameters
+     * @param {Array<string>} baseContracts Optional array of base contract names or hashes
+     * @returns Transaction result
+     */
+    async deployDerivedContract(signer, contract, baseContractIdentifier, constructorParameters = []) {
+        // Try to get base contract by name or hash
+        if (baseContractIdentifier) {
+            const baseContract = contractRegistry.getBaseContract(baseContractIdentifier);
+            if (!baseContract) {
+                throw new Error(`Base contract '${baseContractIdentifier}' not found. Register it first using registerBaseContract.`);
+            }
+        }
+        // Parse contract to check for inheritance
+        const inheritanceInfo = parseContractInheritance(contract);
+        // Deploy the contract
+        const message = await createContractMessage(await signer.address, contract, constructorParameters);
+        // If contract has dependencies, register them
+        if (inheritanceInfo.hasInheritance && inheritanceInfo.baseClass && baseContractIdentifier) {
+            const baseHash = contractRegistry.getHashForName(inheritanceInfo.baseClass);
+            if (baseHash) {
+                const contractHash = await message.hash();
+                contractRegistry.registerDependencies(contractHash, [baseHash]);
+            }
+        }
+        return this.deployContractMessage(signer, message);
+    }
     async deployContractMessage(signer, message) {
         try {
             await globalThis.contractStore.put(await message.hash(), message.encoded);
@@ -269,6 +563,30 @@ class Contract extends Transaction {
         transaction = await signTransaction(await this.createTransaction(transaction), signer);
         return this.sendTransaction(transaction);
     }
+    /**
+     * Check if a class is derived from another class
+     * @param derivedClass The class to check
+     * @param baseClass The potential base class
+     * @returns true if derivedClass extends baseClass
+     */
+    isDerivedFrom(derivedClass, baseClass) {
+        return isDerivedFrom(derivedClass, baseClass);
+    }
+    /**
+     * Parse contract code to extract inheritance information
+     * @param contractCode The contract code to parse
+     * @returns Inheritance information
+     */
+    parseContractInheritance(contractCode) {
+        return parseContractInheritance(contractCode);
+    }
+    /**
+     * Get the contract registry instance
+     * @returns {ContractRegistry} The contract registry
+     */
+    getRegistry() {
+        return contractRegistry;
+    }
 }
 
 // import State from './state'
@@ -295,6 +613,12 @@ class Machine {
             }
         };
         this.wantList = [];
+        this.ready = new Promise((resolve) => {
+            this.readyResolve = resolve;
+        });
+        this.init(blocks);
+    }
+    init(blocks) {
         // @ts-ignore
         return this.#init(blocks);
     }
@@ -354,8 +678,14 @@ class Machine {
             case 'ask': {
                 if (data.question === 'contract' || data.question === 'transaction') {
                     try {
-                        const input = await peernet.get(data.input);
-                        this.worker.postMessage({ id: data.id, input });
+                        const input = await peernet.get(data.input, data.question);
+                        if (input === undefined) {
+                            this.worker.postMessage({ id: data.id, error: `could not get ${data.question} @${data.input}` });
+                            this.wantList.push(data.input);
+                        }
+                        else {
+                            this.worker.postMessage({ id: data.id, input });
+                        }
                     }
                     catch (error) {
                         console.error(error);
@@ -530,6 +860,7 @@ class Machine {
                 }
             };
             this.worker.postMessage(message);
+            this.readyResolve(this);
         });
     }
     async #runContract(contractMessage) {
@@ -571,6 +902,8 @@ class Machine {
                 let message;
                 if (!(await globalThis.contractStore.has(parameters[0]))) {
                     message = await peernet.get(parameters[0], 'contract');
+                    if (!message)
+                        throw new Error(`contract ${parameters[0]} not available`);
                     message = await new ContractMessage(message);
                     await globalThis.contractStore.put(await message.hash(), message.encoded);
                 }
@@ -588,7 +921,12 @@ class Machine {
         return new Promise((resolve, reject) => {
             // @ts-ignore
             const id = randombytes(20).toString('hex');
+            const timeout = setTimeout(() => {
+                pubsub.unsubscribe(id, onmessage);
+                reject(new Error(`Machine.execute timeout for ${contract}.${method}`));
+            }, 30000); // 30 second timeout for machine operations
             const onmessage = (message) => {
+                clearTimeout(timeout);
                 pubsub.unsubscribe(id, onmessage);
                 if (message?.error)
                     reject(new ExecutionError(message.error));
@@ -611,7 +949,12 @@ class Machine {
     get(contract, method, parameters) {
         return new Promise((resolve, reject) => {
             const id = randombytes(20).toString();
+            const timeout = setTimeout(() => {
+                pubsub.unsubscribe(id, onmessage);
+                reject(new Error(`Machine.get timeout for ${contract}.${method}`));
+            }, 30000); // 30 second timeout for machine operations
             const onmessage = (message) => {
+                clearTimeout(timeout);
                 pubsub.unsubscribe(id, onmessage);
                 resolve(message);
             };
@@ -631,7 +974,12 @@ class Machine {
         return new Promise((resolve, reject) => {
             // @ts-ignore
             const id = randombytes(20).toString('hex');
+            const timeout = setTimeout(() => {
+                pubsub.unsubscribe(id, onmessage);
+                reject(new Error(`Machine.has timeout for ${address}`));
+            }, 10000); // 10 second timeout
             const onmessage = (message) => {
+                clearTimeout(timeout);
                 pubsub.unsubscribe(id, onmessage);
                 if (message?.error)
                     reject(message.error);
@@ -652,7 +1000,12 @@ class Machine {
         return new Promise((resolve, reject) => {
             // @ts-ignore
             const id = randombytes(20).toString('hex');
+            const timeout = setTimeout(() => {
+                pubsub.unsubscribe(id, onmessage);
+                reject(new Error(`Machine.#askWorker timeout for ${type}`));
+            }, 30000);
             const onmessage = (message) => {
+                clearTimeout(timeout);
                 pubsub.unsubscribe(id, onmessage);
                 if (message?.error)
                     reject(message.error);
@@ -889,7 +1242,7 @@ class State extends Contract {
                 response: { blocks: await globalThis.blockStore.keys() }
             });
         };
-        this.#loadBlockTransactions = (transactions) => Promise.all(transactions.map(async (transaction) => new TransactionMessage(await peernet.get(transaction))));
+        this.#loadBlockTransactions = (transactions) => Promise.all(transactions.map(async (transaction) => new TransactionMessage(await peernet.get(transaction, 'transaction'))));
         this.#getLastTransactions = async () => {
             let lastTransactions = (await Promise.all((await this.blocks)
                 // @ts-ignore
@@ -918,6 +1271,7 @@ class State extends Contract {
     #lastBlockHandler;
     #knownBlocksHandler;
     async init() {
+        log('State init start');
         this.jobber = new Jobber(this.resolveTimeout);
         await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler);
         await globalThis.peernet.addRequestHandler('knownBlocks', this.#knownBlocksHandler);
@@ -925,31 +1279,42 @@ class State extends Contract {
         let localBlockHash;
         let blockMessage;
         let localBlock;
+        log('State init before try-catch');
         try {
             const rawBlock = await globalThis.chainStore.has('lastBlock');
+            log('State init after has lastBlock check');
             if (rawBlock) {
+                log('State init after has lastBlock found');
+                log(rawBlock);
                 localBlockHash = new TextDecoder().decode(await globalThis.chainStore.get('lastBlock'));
+                console.log(localBlockHash);
                 if (localBlockHash !== '0x0') {
-                    blockMessage = await globalThis.peernet.get(localBlockHash, 'block');
+                    blockMessage = await globalThis.blockStore.get(localBlockHash);
+                    console.log(blockMessage);
                     blockMessage = await new BlockMessage(blockMessage);
                     localBlock = { ...blockMessage.decoded, hash: localBlockHash };
                 }
+                log('State init after localBlock set');
             }
             else {
                 localBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
             }
         }
         catch {
+            console.log('e');
+            log('State init middle');
             localBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
         }
+        log('State init middle');
         try {
+            log('fetching known blocks from blockStore');
             this.knownBlocks = await blockStore.keys();
         }
         catch (error) {
             debug$1('no local known blocks found');
         }
         try {
-            if (localBlock.hash && localBlock.hash !== '0x0') {
+            if (localBlock?.hash && localBlock.hash !== '0x0') {
                 try {
                     const states = {
                         lastBlock: JSON.parse(new TextDecoder().decode(await globalThis.stateStore.get('lastBlock')))
@@ -965,7 +1330,10 @@ class State extends Contract {
             else {
                 await this.resolveBlocks();
             }
-            this.#machine = await new Machine(this.#blocks);
+            const machine = new Machine(this.#blocks);
+            console.log(machine);
+            await machine.ready;
+            this.#machine = machine;
             const lastBlock = await this.#machine.lastBlock;
             if (lastBlock.hash !== '0x0') {
                 this.updateState(new BlockMessage(lastBlock));
@@ -986,8 +1354,12 @@ class State extends Contract {
             const hash = await message.hash();
             await globalThis.chainStore.put('lastBlock', hash);
             globalThis.pubsub.publish('lastBlock', message.encoded);
-            if (!this.#machine)
-                this.#machine = await new Machine(this.#blocks);
+            if (!this.#machine) {
+                const machine = new Machine(this.#blocks);
+                console.log(machine);
+                await machine.ready;
+                this.#machine = machine;
+            }
             await this.#machine.updateState();
         }
         catch (error) {
@@ -1451,16 +1823,21 @@ class State extends Contract {
     }
     async triggerLoad() {
         if (this.#blocks?.length > 0) {
-            this.#machine = await new Machine(this.#blocks);
+            const machine = new Machine(this.#blocks);
+            console.log(machine);
+            await machine.ready;
+            this.#machine = machine;
         }
     }
 }
 
+const currentVersion = '0.1.1';
+
 class VersionControl extends State {
     constructor(config) {
         super(config);
     }
-    #currentVersion = '0.1.0';
+    #currentVersion = currentVersion;
     #reachedOneZeroZero = false;
     async #setCurrentVersion() {
         this.version = this.#currentVersion;
@@ -1847,6 +2224,7 @@ const debug = createDebugger('leofcoin/chain');
 class Chain extends VersionControl {
     #state;
     #slotTime;
+    #blockTime; // 6 second target block time
     /** {Address[]} */
     #validators;
     /** {Boolean} */
@@ -1861,6 +2239,7 @@ class Chain extends VersionControl {
     constructor(config) {
         super(config);
         this.#slotTime = 10000;
+        this.#blockTime = 6000; // 6 second target block time
         this.utils = {};
         /** {Address[]} */
         this.#validators = [];
@@ -1872,14 +2251,16 @@ class Chain extends VersionControl {
         this.#peerConnectionRetries = new Map();
         this.#maxPeerRetries = 5;
         this.#peerRetryDelay = 5000;
+        this.ready = new Promise((resolve) => {
+            this.readyResolve = resolve;
+        });
         this.#addTransaction = async (message) => {
             const transaction = new TransactionMessage(message);
             const hash = await transaction.hash();
             // if (await transactionPoolStore.has(hash)) await transactionPoolStore.delete(hash)
             debug(`added ${hash}`);
         };
-        // @ts-ignore
-        return this.#init();
+        this.#init();
     }
     get nativeToken() {
         return addresses.nativeToken;
@@ -1893,13 +2274,20 @@ class Chain extends VersionControl {
             return true;
         return false;
     }
+    #sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
     async #runEpoch() {
+        if (this.#runningEpoch)
+            return;
         this.#runningEpoch = true;
         console.log('epoch');
         const validators = await this.staticCall(addresses.validators, 'validators');
         console.log({ validators });
-        if (!validators.includes(peernet.selectedAccount))
+        if (!validators.includes(peernet.selectedAccount)) {
+            this.#runningEpoch = false;
             return;
+        }
         const start = Date.now();
         try {
             await this.#createBlock();
@@ -1909,10 +2297,16 @@ class Chain extends VersionControl {
         }
         const end = Date.now();
         console.log((end - start) / 1000 + ' s');
-        if (await this.hasTransactionToHandle())
-            return this.#runEpoch();
+        // enforce target block time to avoid tight loops
+        const elapsed = end - start;
+        const remaining = this.#blockTime - elapsed;
+        const hasMore = await this.hasTransactionToHandle();
+        // Only delay if there's no backlog; if backlog exists, continue immediately
+        if (!hasMore && remaining > 0)
+            await this.#sleep(remaining);
         this.#runningEpoch = false;
-        // if (await this.hasTransactionToHandle() && !this.#runningEpoch) return this.#runEpoch()
+        if (hasMore)
+            return this.#runEpoch();
     }
     async #setup() {
         const contracts = [
@@ -1947,13 +2341,17 @@ class Chain extends VersionControl {
         this.#participants = [];
         this.#participating = false;
         this.#connectionMonitor = new ConnectionMonitor();
+        log$1('[chain] init:start');
         const initialized = await globalThis.contractStore.has(addresses.contractFactory);
+        log$1(`chain initialized: ${initialized}`);
         if (!initialized)
             await this.#setup();
         this.utils = { formatUnits, parseUnits };
         // this.#state = new State()
+        console.log('init');
         // todo some functions rely on state
         await super.init();
+        log$1('super init done');
         // Start connection monitoring
         this.#connectionMonitor.start(this.version);
         await globalThis.peernet.addRequestHandler('bw-request-message', () => {
@@ -1976,7 +2374,8 @@ class Chain extends VersionControl {
         globalThis.peernet.subscribe('validator:timeout', this.#validatorTimeout.bind(this));
         globalThis.pubsub.subscribe('peer:connected', this.#peerConnected.bind(this));
         globalThis.pubsub.publish('chain:ready', true);
-        return this;
+        console.log('[chain] init:done');
+        this.readyResolve(true);
     }
     async #invalidTransaction(hash) {
         hash = new TextDecoder().decode(hash);
@@ -2010,8 +2409,16 @@ class Chain extends VersionControl {
         const transactions = await globalThis.transactionPoolStore.keys();
         const transactionsToGet = [];
         for (const key of transactionsInPool) {
-            !transactions.includes(key) &&
-                transactionsToGet.push(transactionPoolStore.put(key, await peernet.get(key, 'transaction')));
+            let txData;
+            try {
+                txData = await globalThis.peernet.get(key, 'transaction');
+            }
+            catch (error) {
+                debug(`Failed to get transaction ${key}:`, error?.message ?? error);
+            }
+            if (txData !== undefined && !transactions.includes(key)) {
+                transactionsToGet.push(transactionPoolStore.put(key, txData));
+            }
         }
         return Promise.all(transactionsToGet);
     }
@@ -2177,23 +2584,29 @@ class Chain extends VersionControl {
         // peerReputation(peerId)
         // {bandwith: {up, down}, uptime}
         this.#participating = true;
-        if (!(await this.staticCall(addresses.validators, 'has', [address]))) {
-            const rawTransaction = {
-                from: address,
-                to: addresses.validators,
-                method: 'addValidator',
-                params: [address],
-                nonce: (await this.getNonce(address)) + 1,
-                timestamp: Date.now()
-            };
-            const transaction = await signTransaction(rawTransaction, globalThis.peernet.identity);
-            try {
-                await this.sendTransaction(transaction);
-            }
-            catch (error) {
-                console.error(error);
+        try {
+            if (!(await this.staticCall(addresses.validators, 'has', [address]))) {
+                const rawTransaction = {
+                    from: address,
+                    to: addresses.validators,
+                    method: 'addValidator',
+                    params: [address],
+                    nonce: (await this.getNonce(address)) + 1,
+                    timestamp: Date.now()
+                };
+                const transaction = await signTransaction(rawTransaction, globalThis.peernet.identity);
+                try {
+                    await this.sendTransaction(transaction);
+                }
+                catch (error) {
+                    console.error(error);
+                }
             }
         }
+        catch (error) {
+            debug('Error in participate:', error.message);
+            // Continue anyway - validator check is optional
+        }
         if ((await this.hasTransactionToHandle()) && !this.#runningEpoch && this.#participating)
             await this.#runEpoch();
     }
@@ -2216,6 +2629,7 @@ class Chain extends VersionControl {
                 block.fees = block.fees += await calculateFee(transaction.decoded);
             }
             await globalThis.accountsStore.put(transaction.decoded.from, new TextEncoder().encode(String(transaction.decoded.nonce)));
+            // Don't cache nonce during parallel processing - always query pool
             await transactionStore.put(hash, await transaction.encode());
         }
         catch (e) {