@leofcoin/chain 1.7.149 → 1.7.151

package/exports/browser/chain.js

@@ -4128,7 +4128,6 @@ class ExecutionError extends LeofcoinError {
 class ContractDeploymentError extends LeofcoinError {
     name = 'ContractDeploymentError';
 }
-const isResolveError = (error) => error.name === 'ResolveError';
 const isExecutionError = (error) => error.name === 'ExecutionError';
 
 // import State from './state'
@@ -4599,74 +4598,32 @@ class Machine {
     }
 }
 
-class Jobber {
-    constructor(timeout) {
-        this.busy = false;
-        this.timeout = timeout;
-    }
-    add(fn) {
-        this.busy = true;
-        return new Promise(async (resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject('timeout');
-            }, this.timeout);
-            this.destroy = () => {
-                clearTimeout(timeout);
-                this.busy = false;
-                resolve('stopped');
-            };
-            try {
-                const result = await fn();
-                clearTimeout(timeout);
-                this.busy = false;
-                resolve(result);
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                reject(error);
-            }
-        });
-    }
-}
-
 const debug$1 = createDebugger('leofcoin/state');
 class State extends Contract {
-    #resolveErrored;
-    #lastResolvedTime;
-    #lastResolved;
-    #resolving;
-    #resolveErrorCount;
-    #syncState;
-    #chainState;
-    #lastBlockInQue;
-    #syncErrorCount;
     #blockHashMap;
-    #chainSyncing;
     #blocks;
-    #totalSize;
     #machine;
     #loaded;
+    // Sync state
+    #syncing;
+    #syncErrorCount;
+    // Block resolution state
+    #resolvingBlocks;
+    #maxConcurrentResolves;
+    #totalSize;
     /**
      * contains transactions we need before we can successfully load
      */
     get wantList() {
         return this.#machine?.wantList ?? this._wantList;
     }
-    get state() {
-        return {
-            sync: this.#syncState,
-            chain: this.#chainState
-        };
-    }
-    get blockHashMap() {
-        return this.#blockHashMap.entries();
-    }
     get loaded() {
         return this.#loaded;
     }
-    get resolving() {
-        return this.#resolving;
+    get isSyncing() {
+        return this.#syncing;
     }
+    // Delegate to machine
     get contracts() {
         return this.#machine.contracts;
     }
@@ -4709,35 +4666,38 @@ class State extends Contract {
     get lastBlockHeight() {
         return this.#machine ? this.#machine.lastBlockHeight : 0;
     }
-    getBlock(index) {
-        return this.#machine.getBlock(index);
-    }
-    getBlocks(from, to) {
-        return this.#machine.getBlocks(from, to);
-    }
     get totalSize() {
         return this.#totalSize;
     }
     get machine() {
         return this.#machine;
     }
+    get blockHashMap() {
+        return this.#blockHashMap.entries();
+    }
+    getBlock(index) {
+        return this.#machine.getBlock(index);
+    }
+    getBlocks(from, to) {
+        return this.#machine.getBlocks(from, to);
+    }
     constructor(config) {
         super(config);
-        this.#lastResolvedTime = 0;
-        this.#resolving = false;
-        this.#resolveErrorCount = 0;
-        this.#chainState = 'loading';
-        this.#syncErrorCount = 0;
         this.#blockHashMap = new Map();
-        this.#chainSyncing = false;
         this.#blocks = [];
+        this.#loaded = false;
+        // Sync state
+        this.#syncing = false;
+        this.#syncErrorCount = 0;
+        // Block resolution state
+        this.#resolvingBlocks = new Set();
+        this.#maxConcurrentResolves = 10;
         this.knownBlocks = [];
         this.#totalSize = 0;
-        this.#loaded = false;
         this._wantList = [];
         this.#chainStateHandler = () => {
             return new globalThis.peernet.protos['peernet-response']({
-                response: this.#chainState
+                response: { syncing: this.#syncing, loaded: this.#loaded }
             });
         };
         this.#lastBlockHandler = async () => {
@@ -4779,67 +4739,43 @@ class State extends Contract {
     #lastBlockHandler;
     #knownBlocksHandler;
     async init() {
-        this.jobber = new Jobber(this.resolveTimeout);
-        await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler);
-        await globalThis.peernet.addRequestHandler('knownBlocks', this.#knownBlocksHandler);
-        await globalThis.peernet.addRequestHandler('chainState', this.#chainStateHandler);
-        let localBlockHash;
-        let blockMessage;
-        let localBlock;
+        // Register request handlers
+        await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
+        await globalThis.peernet.addRequestHandler('knownBlocks', this.#knownBlocksHandler.bind(this));
+        await globalThis.peernet.addRequestHandler('chainState', this.#chainStateHandler.bind(this));
         try {
-            const rawBlock = await globalThis.chainStore.has('lastBlock');
-            if (rawBlock) {
-                localBlockHash = new TextDecoder().decode(await globalThis.chainStore.get('lastBlock'));
-                if (localBlockHash !== '0x0') {
-                    blockMessage = await globalThis.peernet.get(localBlockHash, 'block');
-                    blockMessage = await new BlockMessage(blockMessage);
+            // Load local block state
+            let localBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
+            try {
+                const localBlockHash = new TextDecoder().decode(await globalThis.chainStore.get('lastBlock'));
+                if (localBlockHash && localBlockHash !== '0x0') {
+                    const blockMessage = await new BlockMessage(await globalThis.peernet.get(localBlockHash, 'block'));
                     localBlock = { ...blockMessage.decoded, hash: localBlockHash };
                 }
             }
-            else {
-                localBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
+            catch (error) {
+                debug$1('No local block found');
             }
-        }
-        catch {
-            localBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
-        }
-        try {
-            this.knownBlocks = await blockStore.keys();
-        }
-        catch (error) {
-            debug$1('no local known blocks found');
-        }
-        try {
-            if (localBlock.hash && localBlock.hash !== '0x0') {
-                try {
-                    const states = {
-                        lastBlock: JSON.parse(new TextDecoder().decode(await globalThis.stateStore.get('lastBlock')))
-                    };
-                    if (blockMessage.decoded.index > states.lastBlock.index)
-                        await this.resolveBlocks();
-                }
-                catch (error) {
-                    // no states found, try resolving blocks
-                    await this.resolveBlocks();
-                }
+            // Load known blocks
+            try {
+                this.knownBlocks = await globalThis.blockStore.keys();
             }
-            else {
-                await this.resolveBlocks();
+            catch (error) {
+                debug$1('No known blocks found');
             }
+            // Initialize machine and resolve blocks if needed
             this.#machine = await new Machine(this.#blocks);
+            if (localBlock.hash !== '0x0') {
+                await this.resolveBlock(localBlock.hash);
+            }
             const lastBlock = await this.#machine.lastBlock;
             if (lastBlock.hash !== '0x0') {
-                this.updateState(new BlockMessage(lastBlock));
+                await this.updateState(new BlockMessage(lastBlock));
             }
             this.#loaded = true;
-            // await this.#loadBlocks(this.#blocks)
         }
         catch (error) {
-            console.log('e');
-            if (isResolveError(error)) {
-                console.error(error);
-            }
-            console.log(error);
+            console.error('Failed to initialize state:', error);
         }
     }
     async updateState(message) {
@@ -4873,45 +4809,40 @@ class State extends Contract {
         return block;
     }
     async #resolveBlock(hash) {
-        let index = this.#blockHashMap.get(hash);
-        let localHash = '0x0';
-        try {
-            if (await globalThis.stateStore.has('lastBlock'))
-                localHash = await globalThis.stateStore.get('lastBlock');
-        }
-        catch (error) {
-            globalThis.stateStore.put('lastBlock', new TextEncoder().encode('0x0'));
-            debug$1('no local state found');
+        if (this.#resolvingBlocks.has(hash)) {
+            return; // Already resolving this block
         }
-        debug$1(`resolving block: ${hash} @${index !== undefined ? index : 'unknown'}`);
-        debug$1(`local state hash: ${localHash}`);
-        if (this.#blocks[index]) {
-            // Block already exists, check if we need to resolve previous blocks
-            const previousHash = this.#blocks[index].previousHash;
-            if (previousHash === localHash)
-                return;
-            if (previousHash !== '0x0') {
-                // Previous block not in memory, recursively resolve it
-                return this.resolveBlock(previousHash);
-            }
-            else {
-                // Previous block already exists or is genesis, stop resolving
+        this.#resolvingBlocks.add(hash);
+        try {
+            let index = this.#blockHashMap.get(hash);
+            debug$1(`resolving block: ${hash} @${index !== undefined ? index : 'unknown'}`);
+            if (this.#blocks[index]) {
+                // Block already exists
                 return;
             }
-        }
-        try {
             const block = await this.getAndPutBlock(hash);
-            await Promise.all(block.decoded.transactions.map(async (hash) => {
-                // should be in a transaction store already
-                if (!(await transactionStore.has(hash))) {
-                    const data = await peernet.get(hash, 'transaction');
-                    await transactionStore.put(hash, data);
-                }
-                ;
-                (await transactionPoolStore.has(hash)) && (await transactionPoolStore.delete(hash));
-            }));
             index = block.decoded.index;
             const size = block.encoded.length > 0 ? block.encoded.length : block.encoded.byteLength;
+            // Batch transaction operations
+            const transactionsToFetch = [];
+            const transactionHashes = block.decoded.transactions || [];
+            for (const txHash of transactionHashes) {
+                if (!(await globalThis.transactionStore.has(txHash))) {
+                    transactionsToFetch.push(txHash);
+                }
+            }
+            // Fetch all missing transactions in parallel
+            if (transactionsToFetch.length > 0) {
+                const fetchedTransactions = await Promise.all(transactionsToFetch.map((txHash) => globalThis.peernet.get(txHash, 'transaction')));
+                // Batch store all transactions
+                await Promise.all(transactionsToFetch.map((txHash, i) => globalThis.transactionStore.put(txHash, fetchedTransactions[i])));
+            }
+            // Remove from pool
+            await Promise.all(transactionHashes.map(async (txHash) => {
+                if (await globalThis.transactionPoolStore.has(txHash)) {
+                    await globalThis.transactionPoolStore.delete(txHash);
+                }
+            }));
             this.#totalSize += size;
             this.#blocks[index] = { hash, ...block.decoded };
             this.#blockHashMap.set(hash, index);
@@ -4921,192 +4852,133 @@ class State extends Contract {
             this.#lastResolvedTime = Date.now();
         }
         catch (error) {
-            throw new ResolveError(`block: ${hash}@${index}`);
+            throw new ResolveError(`block: ${hash}`);
         }
-        return;
-    }
-    async resolveBlock(hash) {
-        if (!hash)
-            throw new Error(`expected hash, got: ${hash}`);
-        if (hash === '0x0')
-            return;
-        if (this.#resolving)
-            return 'already resolving';
-        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;
-            try {
-                const lastBlockHash = await globalThis.stateStore.get('lastBlock');
-                if (lastBlockHash === hash) {
-                    this.#resolveErrored = false;
-                    return;
+        finally {
+            this.#resolvingBlocks.delete(hash);
+        }
+    }
+    async #buildBlockChain(latestHash, maxBlocks = 1000) {
+        const chain = [];
+        let currentHash = latestHash;
+        let attempts = 0;
+        while (currentHash !== '0x0' && chain.length < maxBlocks && attempts < maxBlocks + 5) {
+            attempts++;
+            // Check if we already have this block
+            if (this.#blockHashMap.has(currentHash)) {
+                const block = this.#blocks[this.#blockHashMap.get(currentHash)];
+                if (block) {
+                    chain.push(currentHash);
+                    currentHash = block.previousHash;
+                    continue;
                 }
             }
+            chain.push(currentHash);
+            // Try to get the block to find previous hash
+            try {
+                const block = await this.getAndPutBlock(currentHash);
+                currentHash = block.decoded.previousHash;
+            }
             catch (error) {
-                debug$1('no local state found');
+                debug$1(`Could not fetch block ${currentHash} to determine chain: ${error}`);
+                break;
             }
-            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)
-                return this.resolveBlock(hash);
-            this.#resolveErrorCount = 0;
-            this.wantList.push(hash);
-            throw new ResolveError(`block: ${hash}`, { cause: error });
+        return chain;
+    }
+    async #resolveBlocksInParallel(hashes) {
+        // Resolve blocks in parallel with concurrency limit
+        const resolving = [];
+        let index = 0;
+        const resolveNext = async () => {
+            while (index < hashes.length) {
+                const hash = hashes[index++];
+                try {
+                    await this.#resolveBlock(hash);
+                }
+                catch (error) {
+                    debug$1(`Failed to resolve block ${hash}: ${error}`);
+                    this.#blockResolveQueue.push({ hash, retries: 0 });
+                }
+            }
+        };
+        // Start concurrent resolution tasks
+        for (let i = 0; i < Math.min(this.#maxConcurrentResolves, hashes.length); i++) {
+            resolving.push(resolveNext());
         }
+        await Promise.all(resolving);
     }
-    async resolveBlocks() {
-        // Don't re-resolve if already syncing or resolving
-        if (this.#chainSyncing || this.#resolving) {
-            debug$1('Already syncing or resolving, skipping resolveBlocks()');
+    async resolveBlock(hash) {
+        if (!hash || hash === '0x0')
             return;
-        }
+        if (this.#syncing)
+            return;
+        this.#syncing = true;
+        this.#syncErrorCount = 0;
         try {
-            if (this.jobber.busy && this.jobber.destroy) {
-                await this.jobber.destroy();
+            debug$1(`Building block chain from ${hash}`);
+            const blockChain = await this.#buildBlockChain(hash);
+            debug$1(`Built chain of ${blockChain.length} blocks`);
+            if (blockChain.length > 0) {
+                await this.#resolveBlocksInParallel(blockChain);
             }
         }
         catch (error) {
-            console.error(error);
-        }
-        try {
-            const localBlock = await globalThis.chainStore.get('lastBlock');
-            const hash = new TextDecoder().decode(localBlock);
-            if (hash && hash !== '0x0') {
-                debug$1(`Resolving blocks from hash: ${hash}`);
-                await this.resolveBlock(hash);
-            }
+            console.error('Block resolution failed:', error);
+            this.wantList.push(hash);
         }
-        catch (error) {
-            console.log(error);
-            this.#chainSyncing = false;
-            this.#syncState = 'errored';
-            this.#resolveErrored = true;
-            return this.restoreChain();
-            // console.log(e);
+        finally {
+            this.#syncing = false;
         }
     }
-    async restoreChain() {
+    async resolveBlocks() {
+        if (this.#syncing)
+            return;
         try {
-            const { hash } = await this.#getLatestBlock();
-            await globalThis.chainStore.put('lastBlock', hash);
+            const localBlock = await globalThis.chainStore.get('lastBlock');
+            const hash = new TextDecoder().decode(localBlock);
             if (hash && hash !== '0x0') {
                 await this.resolveBlock(hash);
             }
         }
         catch (error) {
-            console.log(error);
-            this.#resolveErrored = true;
-            this.#resolveErrorCount += 1;
-            this.#resolving = false;
-            return this.restoreChain();
-            // console.log(e);
+            debug$1('Failed to resolve blocks:', error);
         }
     }
     async syncChain(lastBlock) {
-        console.log('check if can sync');
-        if (!this.shouldSync)
-            return;
-        console.log('starting sync');
-        this.#syncState = 'syncing';
-        this.#chainSyncing = true;
-        try {
-            if (this.jobber.busy && this.jobber.destroy) {
-                await this.jobber.destroy();
-            }
-        }
-        catch (error) {
-            console.error(error);
-        }
+        if (this.#syncing)
+            return 'syncing';
         if (!lastBlock)
             lastBlock = await this.#getLatestBlock();
-        if (globalThis.peernet.peers.length === 0)
-            return 'connectionless';
-        try {
-            await this.#syncChain(lastBlock);
-        }
-        catch (error) {
-            this.#syncErrorCount += 1;
-            if (this.#syncErrorCount < 3)
-                return this.syncChain(lastBlock);
-            this.#syncErrorCount = 0;
-            this.#chainSyncing = false;
-            this.#syncState = 'errored';
-            return this.#syncState;
-        }
-        if (lastBlock.index === this.#lastBlockInQue?.index)
-            this.#lastBlockInQue = undefined;
-        this.#syncErrorCount = 0;
-        this.#chainSyncing = false;
-        if (this.#lastBlockInQue)
-            return this.syncChain(this.#lastBlockInQue);
-        this.#syncState = 'synced';
-        return this.#syncState;
-    }
-    async #syncChain(lastBlock) {
+        this.#syncing = true;
         try {
-            // if (this.knownBlocks?.length === Number(lastBlock.index) + 1) {
-            //   let promises = []
-            //   promises = await Promise.allSettled(
-            //     this.knownBlocks.map(async (address) => {
-            //       const has = await globalThis.peernet.has(address)
-            //       return { has, address }
-            //     })
-            //   )
-            //   promises = promises.filter(({ status, value }) => status === 'fulfilled' && !value.has)
-            //   await Promise.allSettled(promises.map(({ value }) => this.getAndPutBlock(value.address)))
-            // }
-            const localBlock = await this.lastBlock;
-            const localIndex = localBlock ? Number(localBlock.index) : -1;
-            const remoteIndex = Number(lastBlock.index);
-            const remoteBlockHash = lastBlock.hash;
-            // Get the local state hash from chainStore
-            let localStateHash = '0x0';
-            try {
-                localStateHash = new TextDecoder().decode(await globalThis.chainStore.get('lastBlock'));
-            }
-            catch (error) {
-                debug$1(`No local state hash found: ${error}`);
-            }
-            debug$1(`Local block height: ${localIndex}, remote block height: ${remoteIndex}`);
-            debug$1(`Local state hash: ${localStateHash}, remote block hash: ${remoteBlockHash}`);
-            // Skip syncing if remote block hash is 0x0 (invalid state)
-            if (remoteBlockHash === '0x0') {
-                debug$1(`Remote block hash is 0x0, skipping sync`);
-                return;
+            if (globalThis.peernet.peers.length === 0) {
+                this.#syncing = false;
+                return 'connectionless';
             }
-            // Use state hash comparison: only resolve if remote hash differs from local state hash
-            if (localStateHash !== remoteBlockHash) {
-                // Remote block hash differs from our local state, need to resolve
-                debug$1(`Resolving remote block: ${remoteBlockHash} @${remoteIndex} (differs from local state)`);
-                await this.resolveBlock(remoteBlockHash);
-                const blocksSynced = remoteIndex - localIndex;
-                debug$1(`Resolved ${blocksSynced} new block(s)`);
-                const blocks = this.#blocks;
-                debug$1(`Loading blocks from index ${localIndex + 1} to ${remoteIndex}`);
-                const start = localIndex + 1;
-                if (this.#machine && blocks.length > start) {
-                    await this.#loadBlocks(blocks.slice(start));
-                }
-                // Update state with the latest block
-                if (blocks.length > 0) {
-                    await this.updateState(new BlockMessage(blocks[blocks.length - 1]));
-                }
+            await this.resolveBlock(lastBlock.hash);
+            const blocks = this.#blocks;
+            const localIndex = (await this.lastBlock).index || -1;
+            const start = Math.max(0, localIndex + 1);
+            if (this.#machine && blocks.length > start) {
+                await this.#loadBlocks(blocks.slice(start));
             }
-            else {
-                debug$1(`Block already in local state. Remote hash: ${remoteBlockHash} matches local state`);
+            if (blocks.length > 0) {
+                await this.updateState(new BlockMessage(blocks[blocks.length - 1]));
             }
+            this.#syncErrorCount = 0;
+            this.#syncing = false;
+            return 'synced';
         }
         catch (error) {
-            console.log(error);
-            throw error;
+            this.#syncErrorCount++;
+            if (this.#syncErrorCount < 3) {
+                this.#syncing = false;
+                return this.syncChain(lastBlock);
+            }
+            this.#syncErrorCount = 0;
+            this.#syncing = false;
+            return 'errored';
         }
     }
     async #getLatestBlock() {
@@ -5157,7 +5029,7 @@ class State extends Contract {
                 let node = await globalThis.peernet.prepareMessage(data);
                 let message = await peer.request(node.encode());
                 message = await new globalThis.peernet.protos['peernet-response'](message);
-                this.knownBlocks = message.decoded.response;
+                this.wantList.push(...message.decoded.response);
             }
         }
         return latest;
@@ -5277,26 +5149,13 @@ class State extends Contract {
         });
     }
     get canSync() {
-        if (this.#chainSyncing)
-            return false;
-        return true;
+        return !this.#syncing;
     }
     get shouldSync() {
-        if (this.#chainSyncing)
+        if (this.#syncing)
             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);
-        if (compatiblePeers.length === 0) {
-            debug$1('No compatible peers available for sync');
-            return false;
-        }
-        if (!this.#chainSyncing ||
-            this.#resolveErrored ||
-            this.#syncState === 'errored' ||
-            this.#syncState === 'connectionless' ||
-            this.#lastResolvedTime + this.resolveTimeout > Date.now())
-            return true;
-        return false;
+        return compatiblePeers.length > 0;
     }
     async #waitForPeers(timeoutMs = 30000) {
         return new Promise((resolve) => {

package/exports/chain.js

@@ -6,7 +6,7 @@ import { calculateFee, createContractMessage, signTransaction, contractFactoryMe
 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 { ContractDeploymentError, ExecutionError, ResolveError, isExecutionError } from '@leofcoin/errors';
 
 const limit = 1800;
 const transactionLimit = 1000;
@@ -739,74 +739,32 @@ class Machine {
     }
 }
 
-class Jobber {
-    constructor(timeout) {
-        this.busy = false;
-        this.timeout = timeout;
-    }
-    add(fn) {
-        this.busy = true;
-        return new Promise(async (resolve, reject) => {
-            const timeout = setTimeout(() => {
-                reject('timeout');
-            }, this.timeout);
-            this.destroy = () => {
-                clearTimeout(timeout);
-                this.busy = false;
-                resolve('stopped');
-            };
-            try {
-                const result = await fn();
-                clearTimeout(timeout);
-                this.busy = false;
-                resolve(result);
-            }
-            catch (error) {
-                clearTimeout(timeout);
-                reject(error);
-            }
-        });
-    }
-}
-
 const debug$1 = createDebugger('leofcoin/state');
 class State extends Contract {
-    #resolveErrored;
-    #lastResolvedTime;
-    #lastResolved;
-    #resolving;
-    #resolveErrorCount;
-    #syncState;
-    #chainState;
-    #lastBlockInQue;
-    #syncErrorCount;
     #blockHashMap;
-    #chainSyncing;
     #blocks;
-    #totalSize;
     #machine;
     #loaded;
+    // Sync state
+    #syncing;
+    #syncErrorCount;
+    // Block resolution state
+    #resolvingBlocks;
+    #maxConcurrentResolves;
+    #totalSize;
     /**
      * contains transactions we need before we can successfully load
      */
     get wantList() {
         return this.#machine?.wantList ?? this._wantList;
     }
-    get state() {
-        return {
-            sync: this.#syncState,
-            chain: this.#chainState
-        };
-    }
-    get blockHashMap() {
-        return this.#blockHashMap.entries();
-    }
     get loaded() {
         return this.#loaded;
     }
-    get resolving() {
-        return this.#resolving;
+    get isSyncing() {
+        return this.#syncing;
     }
+    // Delegate to machine
     get contracts() {
         return this.#machine.contracts;
     }
@@ -849,35 +807,38 @@ class State extends Contract {
     get lastBlockHeight() {
         return this.#machine ? this.#machine.lastBlockHeight : 0;
     }
-    getBlock(index) {
-        return this.#machine.getBlock(index);
-    }
-    getBlocks(from, to) {
-        return this.#machine.getBlocks(from, to);
-    }
     get totalSize() {
         return this.#totalSize;
     }
     get machine() {
         return this.#machine;
     }
+    get blockHashMap() {
+        return this.#blockHashMap.entries();
+    }
+    getBlock(index) {
+        return this.#machine.getBlock(index);
+    }
+    getBlocks(from, to) {
+        return this.#machine.getBlocks(from, to);
+    }
     constructor(config) {
         super(config);
-        this.#lastResolvedTime = 0;
-        this.#resolving = false;
-        this.#resolveErrorCount = 0;
-        this.#chainState = 'loading';
-        this.#syncErrorCount = 0;
         this.#blockHashMap = new Map();
-        this.#chainSyncing = false;
         this.#blocks = [];
+        this.#loaded = false;
+        // Sync state
+        this.#syncing = false;
+        this.#syncErrorCount = 0;
+        // Block resolution state
+        this.#resolvingBlocks = new Set();
+        this.#maxConcurrentResolves = 10;
         this.knownBlocks = [];
         this.#totalSize = 0;
-        this.#loaded = false;
         this._wantList = [];
         this.#chainStateHandler = () => {
             return new globalThis.peernet.protos['peernet-response']({
-                response: this.#chainState
+                response: { syncing: this.#syncing, loaded: this.#loaded }
             });
         };
         this.#lastBlockHandler = async () => {
@@ -919,67 +880,43 @@ class State extends Contract {
     #lastBlockHandler;
     #knownBlocksHandler;
     async init() {
-        this.jobber = new Jobber(this.resolveTimeout);
-        await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler);
-        await globalThis.peernet.addRequestHandler('knownBlocks', this.#knownBlocksHandler);
-        await globalThis.peernet.addRequestHandler('chainState', this.#chainStateHandler);
-        let localBlockHash;
-        let blockMessage;
-        let localBlock;
+        // Register request handlers
+        await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
+        await globalThis.peernet.addRequestHandler('knownBlocks', this.#knownBlocksHandler.bind(this));
+        await globalThis.peernet.addRequestHandler('chainState', this.#chainStateHandler.bind(this));
         try {
-            const rawBlock = await globalThis.chainStore.has('lastBlock');
-            if (rawBlock) {
-                localBlockHash = new TextDecoder().decode(await globalThis.chainStore.get('lastBlock'));
-                if (localBlockHash !== '0x0') {
-                    blockMessage = await globalThis.peernet.get(localBlockHash, 'block');
-                    blockMessage = await new BlockMessage(blockMessage);
+            // Load local block state
+            let localBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
+            try {
+                const localBlockHash = new TextDecoder().decode(await globalThis.chainStore.get('lastBlock'));
+                if (localBlockHash && localBlockHash !== '0x0') {
+                    const blockMessage = await new BlockMessage(await globalThis.peernet.get(localBlockHash, 'block'));
                     localBlock = { ...blockMessage.decoded, hash: localBlockHash };
                 }
             }
-            else {
-                localBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
+            catch (error) {
+                debug$1('No local block found');
             }
-        }
-        catch {
-            localBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
-        }
-        try {
-            this.knownBlocks = await blockStore.keys();
-        }
-        catch (error) {
-            debug$1('no local known blocks found');
-        }
-        try {
-            if (localBlock.hash && localBlock.hash !== '0x0') {
-                try {
-                    const states = {
-                        lastBlock: JSON.parse(new TextDecoder().decode(await globalThis.stateStore.get('lastBlock')))
-                    };
-                    if (blockMessage.decoded.index > states.lastBlock.index)
-                        await this.resolveBlocks();
-                }
-                catch (error) {
-                    // no states found, try resolving blocks
-                    await this.resolveBlocks();
-                }
+            // Load known blocks
+            try {
+                this.knownBlocks = await globalThis.blockStore.keys();
             }
-            else {
-                await this.resolveBlocks();
+            catch (error) {
+                debug$1('No known blocks found');
             }
+            // Initialize machine and resolve blocks if needed
             this.#machine = await new Machine(this.#blocks);
+            if (localBlock.hash !== '0x0') {
+                await this.resolveBlock(localBlock.hash);
+            }
             const lastBlock = await this.#machine.lastBlock;
             if (lastBlock.hash !== '0x0') {
-                this.updateState(new BlockMessage(lastBlock));
+                await this.updateState(new BlockMessage(lastBlock));
             }
             this.#loaded = true;
-            // await this.#loadBlocks(this.#blocks)
         }
         catch (error) {
-            console.log('e');
-            if (isResolveError(error)) {
-                console.error(error);
-            }
-            console.log(error);
+            console.error('Failed to initialize state:', error);
         }
     }
     async updateState(message) {
@@ -1013,45 +950,40 @@ class State extends Contract {
         return block;
     }
     async #resolveBlock(hash) {
-        let index = this.#blockHashMap.get(hash);
-        let localHash = '0x0';
-        try {
-            if (await globalThis.stateStore.has('lastBlock'))
-                localHash = await globalThis.stateStore.get('lastBlock');
+        if (this.#resolvingBlocks.has(hash)) {
+            return; // Already resolving this block
         }
-        catch (error) {
-            globalThis.stateStore.put('lastBlock', new TextEncoder().encode('0x0'));
-            debug$1('no local state found');
-        }
-        debug$1(`resolving block: ${hash} @${index !== undefined ? index : 'unknown'}`);
-        debug$1(`local state hash: ${localHash}`);
-        if (this.#blocks[index]) {
-            // Block already exists, check if we need to resolve previous blocks
-            const previousHash = this.#blocks[index].previousHash;
-            if (previousHash === localHash)
-                return;
-            if (previousHash !== '0x0') {
-                // Previous block not in memory, recursively resolve it
-                return this.resolveBlock(previousHash);
-            }
-            else {
-                // Previous block already exists or is genesis, stop resolving
+        this.#resolvingBlocks.add(hash);
+        try {
+            let index = this.#blockHashMap.get(hash);
+            debug$1(`resolving block: ${hash} @${index !== undefined ? index : 'unknown'}`);
+            if (this.#blocks[index]) {
+                // Block already exists
                 return;
             }
-        }
-        try {
             const block = await this.getAndPutBlock(hash);
-            await Promise.all(block.decoded.transactions.map(async (hash) => {
-                // should be in a transaction store already
-                if (!(await transactionStore.has(hash))) {
-                    const data = await peernet.get(hash, 'transaction');
-                    await transactionStore.put(hash, data);
-                }
-                ;
-                (await transactionPoolStore.has(hash)) && (await transactionPoolStore.delete(hash));
-            }));
             index = block.decoded.index;
             const size = block.encoded.length > 0 ? block.encoded.length : block.encoded.byteLength;
+            // Batch transaction operations
+            const transactionsToFetch = [];
+            const transactionHashes = block.decoded.transactions || [];
+            for (const txHash of transactionHashes) {
+                if (!(await globalThis.transactionStore.has(txHash))) {
+                    transactionsToFetch.push(txHash);
+                }
+            }
+            // Fetch all missing transactions in parallel
+            if (transactionsToFetch.length > 0) {
+                const fetchedTransactions = await Promise.all(transactionsToFetch.map((txHash) => globalThis.peernet.get(txHash, 'transaction')));
+                // Batch store all transactions
+                await Promise.all(transactionsToFetch.map((txHash, i) => globalThis.transactionStore.put(txHash, fetchedTransactions[i])));
+            }
+            // Remove from pool
+            await Promise.all(transactionHashes.map(async (txHash) => {
+                if (await globalThis.transactionPoolStore.has(txHash)) {
+                    await globalThis.transactionPoolStore.delete(txHash);
+                }
+            }));
             this.#totalSize += size;
             this.#blocks[index] = { hash, ...block.decoded };
             this.#blockHashMap.set(hash, index);
@@ -1061,192 +993,133 @@ class State extends Contract {
             this.#lastResolvedTime = Date.now();
         }
         catch (error) {
-            throw new ResolveError(`block: ${hash}@${index}`);
+            throw new ResolveError(`block: ${hash}`);
         }
-        return;
-    }
-    async resolveBlock(hash) {
-        if (!hash)
-            throw new Error(`expected hash, got: ${hash}`);
-        if (hash === '0x0')
-            return;
-        if (this.#resolving)
-            return 'already resolving';
-        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;
-            try {
-                const lastBlockHash = await globalThis.stateStore.get('lastBlock');
-                if (lastBlockHash === hash) {
-                    this.#resolveErrored = false;
-                    return;
+        finally {
+            this.#resolvingBlocks.delete(hash);
+        }
+    }
+    async #buildBlockChain(latestHash, maxBlocks = 1000) {
+        const chain = [];
+        let currentHash = latestHash;
+        let attempts = 0;
+        while (currentHash !== '0x0' && chain.length < maxBlocks && attempts < maxBlocks + 5) {
+            attempts++;
+            // Check if we already have this block
+            if (this.#blockHashMap.has(currentHash)) {
+                const block = this.#blocks[this.#blockHashMap.get(currentHash)];
+                if (block) {
+                    chain.push(currentHash);
+                    currentHash = block.previousHash;
+                    continue;
                 }
             }
+            chain.push(currentHash);
+            // Try to get the block to find previous hash
+            try {
+                const block = await this.getAndPutBlock(currentHash);
+                currentHash = block.decoded.previousHash;
+            }
             catch (error) {
-                debug$1('no local state found');
+                debug$1(`Could not fetch block ${currentHash} to determine chain: ${error}`);
+                break;
             }
-            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)
-                return this.resolveBlock(hash);
-            this.#resolveErrorCount = 0;
-            this.wantList.push(hash);
-            throw new ResolveError(`block: ${hash}`, { cause: error });
+        return chain;
+    }
+    async #resolveBlocksInParallel(hashes) {
+        // Resolve blocks in parallel with concurrency limit
+        const resolving = [];
+        let index = 0;
+        const resolveNext = async () => {
+            while (index < hashes.length) {
+                const hash = hashes[index++];
+                try {
+                    await this.#resolveBlock(hash);
+                }
+                catch (error) {
+                    debug$1(`Failed to resolve block ${hash}: ${error}`);
+                    this.#blockResolveQueue.push({ hash, retries: 0 });
+                }
+            }
+        };
+        // Start concurrent resolution tasks
+        for (let i = 0; i < Math.min(this.#maxConcurrentResolves, hashes.length); i++) {
+            resolving.push(resolveNext());
         }
+        await Promise.all(resolving);
     }
-    async resolveBlocks() {
-        // Don't re-resolve if already syncing or resolving
-        if (this.#chainSyncing || this.#resolving) {
-            debug$1('Already syncing or resolving, skipping resolveBlocks()');
+    async resolveBlock(hash) {
+        if (!hash || hash === '0x0')
             return;
-        }
+        if (this.#syncing)
+            return;
+        this.#syncing = true;
+        this.#syncErrorCount = 0;
         try {
-            if (this.jobber.busy && this.jobber.destroy) {
-                await this.jobber.destroy();
+            debug$1(`Building block chain from ${hash}`);
+            const blockChain = await this.#buildBlockChain(hash);
+            debug$1(`Built chain of ${blockChain.length} blocks`);
+            if (blockChain.length > 0) {
+                await this.#resolveBlocksInParallel(blockChain);
             }
         }
         catch (error) {
-            console.error(error);
-        }
-        try {
-            const localBlock = await globalThis.chainStore.get('lastBlock');
-            const hash = new TextDecoder().decode(localBlock);
-            if (hash && hash !== '0x0') {
-                debug$1(`Resolving blocks from hash: ${hash}`);
-                await this.resolveBlock(hash);
-            }
+            console.error('Block resolution failed:', error);
+            this.wantList.push(hash);
         }
-        catch (error) {
-            console.log(error);
-            this.#chainSyncing = false;
-            this.#syncState = 'errored';
-            this.#resolveErrored = true;
-            return this.restoreChain();
-            // console.log(e);
+        finally {
+            this.#syncing = false;
         }
     }
-    async restoreChain() {
+    async resolveBlocks() {
+        if (this.#syncing)
+            return;
         try {
-            const { hash } = await this.#getLatestBlock();
-            await globalThis.chainStore.put('lastBlock', hash);
+            const localBlock = await globalThis.chainStore.get('lastBlock');
+            const hash = new TextDecoder().decode(localBlock);
             if (hash && hash !== '0x0') {
                 await this.resolveBlock(hash);
             }
         }
         catch (error) {
-            console.log(error);
-            this.#resolveErrored = true;
-            this.#resolveErrorCount += 1;
-            this.#resolving = false;
-            return this.restoreChain();
-            // console.log(e);
+            debug$1('Failed to resolve blocks:', error);
         }
     }
     async syncChain(lastBlock) {
-        console.log('check if can sync');
-        if (!this.shouldSync)
-            return;
-        console.log('starting sync');
-        this.#syncState = 'syncing';
-        this.#chainSyncing = true;
-        try {
-            if (this.jobber.busy && this.jobber.destroy) {
-                await this.jobber.destroy();
-            }
-        }
-        catch (error) {
-            console.error(error);
-        }
+        if (this.#syncing)
+            return 'syncing';
         if (!lastBlock)
             lastBlock = await this.#getLatestBlock();
-        if (globalThis.peernet.peers.length === 0)
-            return 'connectionless';
+        this.#syncing = true;
         try {
-            await this.#syncChain(lastBlock);
-        }
-        catch (error) {
-            this.#syncErrorCount += 1;
-            if (this.#syncErrorCount < 3)
-                return this.syncChain(lastBlock);
-            this.#syncErrorCount = 0;
-            this.#chainSyncing = false;
-            this.#syncState = 'errored';
-            return this.#syncState;
-        }
-        if (lastBlock.index === this.#lastBlockInQue?.index)
-            this.#lastBlockInQue = undefined;
-        this.#syncErrorCount = 0;
-        this.#chainSyncing = false;
-        if (this.#lastBlockInQue)
-            return this.syncChain(this.#lastBlockInQue);
-        this.#syncState = 'synced';
-        return this.#syncState;
-    }
-    async #syncChain(lastBlock) {
-        try {
-            // if (this.knownBlocks?.length === Number(lastBlock.index) + 1) {
-            //   let promises = []
-            //   promises = await Promise.allSettled(
-            //     this.knownBlocks.map(async (address) => {
-            //       const has = await globalThis.peernet.has(address)
-            //       return { has, address }
-            //     })
-            //   )
-            //   promises = promises.filter(({ status, value }) => status === 'fulfilled' && !value.has)
-            //   await Promise.allSettled(promises.map(({ value }) => this.getAndPutBlock(value.address)))
-            // }
-            const localBlock = await this.lastBlock;
-            const localIndex = localBlock ? Number(localBlock.index) : -1;
-            const remoteIndex = Number(lastBlock.index);
-            const remoteBlockHash = lastBlock.hash;
-            // Get the local state hash from chainStore
-            let localStateHash = '0x0';
-            try {
-                localStateHash = new TextDecoder().decode(await globalThis.chainStore.get('lastBlock'));
+            if (globalThis.peernet.peers.length === 0) {
+                this.#syncing = false;
+                return 'connectionless';
             }
-            catch (error) {
-                debug$1(`No local state hash found: ${error}`);
-            }
-            debug$1(`Local block height: ${localIndex}, remote block height: ${remoteIndex}`);
-            debug$1(`Local state hash: ${localStateHash}, remote block hash: ${remoteBlockHash}`);
-            // Skip syncing if remote block hash is 0x0 (invalid state)
-            if (remoteBlockHash === '0x0') {
-                debug$1(`Remote block hash is 0x0, skipping sync`);
-                return;
-            }
-            // Use state hash comparison: only resolve if remote hash differs from local state hash
-            if (localStateHash !== remoteBlockHash) {
-                // Remote block hash differs from our local state, need to resolve
-                debug$1(`Resolving remote block: ${remoteBlockHash} @${remoteIndex} (differs from local state)`);
-                await this.resolveBlock(remoteBlockHash);
-                const blocksSynced = remoteIndex - localIndex;
-                debug$1(`Resolved ${blocksSynced} new block(s)`);
-                const blocks = this.#blocks;
-                debug$1(`Loading blocks from index ${localIndex + 1} to ${remoteIndex}`);
-                const start = localIndex + 1;
-                if (this.#machine && blocks.length > start) {
-                    await this.#loadBlocks(blocks.slice(start));
-                }
-                // Update state with the latest block
-                if (blocks.length > 0) {
-                    await this.updateState(new BlockMessage(blocks[blocks.length - 1]));
-                }
+            await this.resolveBlock(lastBlock.hash);
+            const blocks = this.#blocks;
+            const localIndex = (await this.lastBlock).index || -1;
+            const start = Math.max(0, localIndex + 1);
+            if (this.#machine && blocks.length > start) {
+                await this.#loadBlocks(blocks.slice(start));
             }
-            else {
-                debug$1(`Block already in local state. Remote hash: ${remoteBlockHash} matches local state`);
+            if (blocks.length > 0) {
+                await this.updateState(new BlockMessage(blocks[blocks.length - 1]));
             }
+            this.#syncErrorCount = 0;
+            this.#syncing = false;
+            return 'synced';
         }
         catch (error) {
-            console.log(error);
-            throw error;
+            this.#syncErrorCount++;
+            if (this.#syncErrorCount < 3) {
+                this.#syncing = false;
+                return this.syncChain(lastBlock);
+            }
+            this.#syncErrorCount = 0;
+            this.#syncing = false;
+            return 'errored';
         }
     }
     async #getLatestBlock() {
@@ -1297,7 +1170,7 @@ class State extends Contract {
                 let node = await globalThis.peernet.prepareMessage(data);
                 let message = await peer.request(node.encode());
                 message = await new globalThis.peernet.protos['peernet-response'](message);
-                this.knownBlocks = message.decoded.response;
+                this.wantList.push(...message.decoded.response);
             }
         }
         return latest;
@@ -1417,26 +1290,13 @@ class State extends Contract {
         });
     }
     get canSync() {
-        if (this.#chainSyncing)
-            return false;
-        return true;
+        return !this.#syncing;
     }
     get shouldSync() {
-        if (this.#chainSyncing)
+        if (this.#syncing)
             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);
-        if (compatiblePeers.length === 0) {
-            debug$1('No compatible peers available for sync');
-            return false;
-        }
-        if (!this.#chainSyncing ||
-            this.#resolveErrored ||
-            this.#syncState === 'errored' ||
-            this.#syncState === 'connectionless' ||
-            this.#lastResolvedTime + this.resolveTimeout > Date.now())
-            return true;
-        return false;
+        return compatiblePeers.length > 0;
     }
     async #waitForPeers(timeoutMs = 30000) {
         return new Promise((resolve) => {

package/exports/state.d.ts

@@ -1,26 +1,17 @@
 import { BlockMessage } from '@leofcoin/messages';
 import Contract from './contract.js';
 import Machine from './machine.js';
-import Jobber from './jobs/jobber.js';
 import { BlockHash } from './types.js';
-declare type SyncState = 'syncing' | 'synced' | 'errored' | 'connectionless';
-declare type ChainState = 'loading' | 'loaded';
 export default class State extends Contract {
     #private;
     knownBlocks: BlockHash[];
-    jobber: Jobber;
     _wantList: any[];
     /**
      * contains transactions we need before we can successfully load
      */
     get wantList(): string[];
-    get state(): {
-        sync: SyncState;
-        chain: ChainState;
-    };
-    get blockHashMap(): MapIterator<[any, any]>;
     get loaded(): boolean;
-    get resolving(): boolean;
+    get isSyncing(): boolean;
     get contracts(): Promise<any>;
     get totalContracts(): Promise<any>;
     get nativeCalls(): Promise<any>;
@@ -39,10 +30,11 @@ export default class State extends Contract {
         previousHash: string;
     };
     get lastBlockHeight(): Promise<any> | 0;
-    getBlock(index: any): Promise<any>;
-    getBlocks(from?: any, to?: any): Promise<[]>;
     get totalSize(): number;
     get machine(): Machine;
+    get blockHashMap(): MapIterator<[any, any]>;
+    getBlock(index: any): Promise<any>;
+    getBlocks(from?: any, to?: any): Promise<[]>;
     constructor(config: any);
     clearPool(): Promise<void>;
     /**
@@ -53,14 +45,12 @@ export default class State extends Contract {
     updateState(message: BlockMessage): Promise<void>;
     getLatestBlock(): Promise<BlockMessage['decoded']>;
     getAndPutBlock(hash: string): Promise<BlockMessage>;
-    resolveBlock(hash: any): any;
-    resolveBlocks(): Promise<any>;
-    restoreChain(): any;
-    syncChain(lastBlock?: any): Promise<SyncState>;
+    resolveBlock(hash: string): Promise<void>;
+    resolveBlocks(): Promise<void>;
+    syncChain(lastBlock?: any): Promise<'syncing' | 'synced' | 'errored' | 'connectionless'>;
     promiseRequests(promises: any): Promise<unknown>;
     get canSync(): boolean;
     get shouldSync(): boolean;
-    triggerSync(): Promise<SyncState>;
+    triggerSync(): Promise<"syncing" | "synced" | "errored" | "connectionless">;
     triggerLoad(): Promise<void>;
 }
-export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.7.149",
+  "version": "1.7.151",
   "description": "Official javascript implementation",
   "private": false,
   "exports": {