@leofcoin/chain 1.7.150 → 1.7.152

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,77 +4598,36 @@ 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;
+    #lastResolved;
+    #lastResolvedTime;
     #blockResolveQueue;
+    #chainState;
     /**
      * 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;
     }
@@ -4712,38 +4670,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.knownBlocks = [];
-        this.#totalSize = 0;
         this.#loaded = false;
-        this._wantList = [];
+        // Sync state
+        this.#syncing = false;
+        this.#syncErrorCount = 0;
+        // Block resolution state
         this.#resolvingBlocks = new Set();
         this.#maxConcurrentResolves = 10;
-        this.#blockResolveQueue = [];
+        this.knownBlocks = [];
+        this.#totalSize = 0;
+        this._wantList = [];
         this.#chainStateHandler = () => {
             return new globalThis.peernet.protos['peernet-response']({
-                response: this.#chainState
+                response: { syncing: this.#syncing, loaded: this.#loaded }
             });
         };
         this.#lastBlockHandler = async () => {
@@ -4785,67 +4743,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) {
@@ -4979,196 +4913,76 @@ class State extends Contract {
         await Promise.all(resolving);
     }
     async resolveBlock(hash) {
-        if (!hash)
-            throw new Error(`expected hash, got: ${hash}`);
-        if (hash === '0x0')
+        if (!hash || hash === '0x0')
             return;
-        if (this.#resolving) {
-            debug$1('Already resolving, queueing block');
+        if (this.#syncing)
             return;
-        }
-        this.#resolving = true;
+        this.#syncing = true;
+        this.#syncErrorCount = 0;
         try {
-            // Build the entire block chain from latest to genesis
             debug$1(`Building block chain from ${hash}`);
             const blockChain = await this.#buildBlockChain(hash);
             debug$1(`Built chain of ${blockChain.length} blocks`);
-            // Resolve all blocks in parallel
             if (blockChain.length > 0) {
                 await this.#resolveBlocksInParallel(blockChain);
             }
-            this.#resolving = false;
-            this.#resolveErrorCount = 0;
-            this.#resolveErrored = false;
-            try {
-                const lastBlockHash = await globalThis.stateStore.get('lastBlock');
-                if (lastBlockHash === hash) {
-                    debug$1('Resolved to latest block state');
-                    return;
-                }
-            }
-            catch (error) {
-                debug$1('no local state found');
-            }
         }
         catch (error) {
-            console.log({ error });
-            this.#resolveErrorCount += 1;
-            this.#resolving = false;
-            if (this.#resolveErrorCount < 3) {
-                debug$1(`Retry ${this.#resolveErrorCount}/3 for block ${hash}`);
-                return this.resolveBlock(hash);
-            }
-            this.#resolveErrorCount = 0;
+            console.error('Block resolution failed:', error);
             this.wantList.push(hash);
-            throw new ResolveError(`block: ${hash}`, { cause: error });
+        }
+        finally {
+            this.#syncing = false;
         }
     }
     async resolveBlocks() {
-        // Don't re-resolve if already syncing or resolving
-        if (this.#chainSyncing || this.#resolving) {
-            debug$1('Already syncing or resolving, skipping resolveBlocks()');
+        if (this.#syncing)
             return;
-        }
-        try {
-            if (this.jobber.busy && this.jobber.destroy) {
-                await this.jobber.destroy();
-            }
-        }
-        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);
             }
         }
         catch (error) {
-            console.log(error);
-            this.#chainSyncing = false;
-            this.#syncState = 'errored';
-            this.#resolveErrored = true;
-            return this.restoreChain();
-            // console.log(e);
-        }
-    }
-    async restoreChain() {
-        try {
-            const { hash } = await this.#getLatestBlock();
-            await globalThis.chainStore.put('lastBlock', hash);
-            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'));
-            }
-            catch (error) {
-                debug$1(`No local state hash found: ${error}`);
+            if (globalThis.peernet.peers.length === 0) {
+                this.#syncing = false;
+                return 'connectionless';
             }
-            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;
+            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));
             }
-            // 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]));
-                }
-            }
-            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() {
@@ -5339,26 +5153,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,77 +739,36 @@ 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;
+    #lastResolved;
+    #lastResolvedTime;
     #blockResolveQueue;
+    #chainState;
     /**
      * 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;
     }
@@ -852,38 +811,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.knownBlocks = [];
-        this.#totalSize = 0;
         this.#loaded = false;
-        this._wantList = [];
+        // Sync state
+        this.#syncing = false;
+        this.#syncErrorCount = 0;
+        // Block resolution state
         this.#resolvingBlocks = new Set();
         this.#maxConcurrentResolves = 10;
-        this.#blockResolveQueue = [];
+        this.knownBlocks = [];
+        this.#totalSize = 0;
+        this._wantList = [];
         this.#chainStateHandler = () => {
             return new globalThis.peernet.protos['peernet-response']({
-                response: this.#chainState
+                response: { syncing: this.#syncing, loaded: this.#loaded }
             });
         };
         this.#lastBlockHandler = async () => {
@@ -925,67 +884,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) {
@@ -1119,196 +1054,76 @@ class State extends Contract {
         await Promise.all(resolving);
     }
     async resolveBlock(hash) {
-        if (!hash)
-            throw new Error(`expected hash, got: ${hash}`);
-        if (hash === '0x0')
+        if (!hash || hash === '0x0')
             return;
-        if (this.#resolving) {
-            debug$1('Already resolving, queueing block');
+        if (this.#syncing)
             return;
-        }
-        this.#resolving = true;
+        this.#syncing = true;
+        this.#syncErrorCount = 0;
         try {
-            // Build the entire block chain from latest to genesis
             debug$1(`Building block chain from ${hash}`);
             const blockChain = await this.#buildBlockChain(hash);
             debug$1(`Built chain of ${blockChain.length} blocks`);
-            // Resolve all blocks in parallel
             if (blockChain.length > 0) {
                 await this.#resolveBlocksInParallel(blockChain);
             }
-            this.#resolving = false;
-            this.#resolveErrorCount = 0;
-            this.#resolveErrored = false;
-            try {
-                const lastBlockHash = await globalThis.stateStore.get('lastBlock');
-                if (lastBlockHash === hash) {
-                    debug$1('Resolved to latest block state');
-                    return;
-                }
-            }
-            catch (error) {
-                debug$1('no local state found');
-            }
         }
         catch (error) {
-            console.log({ error });
-            this.#resolveErrorCount += 1;
-            this.#resolving = false;
-            if (this.#resolveErrorCount < 3) {
-                debug$1(`Retry ${this.#resolveErrorCount}/3 for block ${hash}`);
-                return this.resolveBlock(hash);
-            }
-            this.#resolveErrorCount = 0;
+            console.error('Block resolution failed:', error);
             this.wantList.push(hash);
-            throw new ResolveError(`block: ${hash}`, { cause: error });
+        }
+        finally {
+            this.#syncing = false;
         }
     }
     async resolveBlocks() {
-        // Don't re-resolve if already syncing or resolving
-        if (this.#chainSyncing || this.#resolving) {
-            debug$1('Already syncing or resolving, skipping resolveBlocks()');
+        if (this.#syncing)
             return;
-        }
-        try {
-            if (this.jobber.busy && this.jobber.destroy) {
-                await this.jobber.destroy();
-            }
-        }
-        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);
             }
         }
         catch (error) {
-            console.log(error);
-            this.#chainSyncing = false;
-            this.#syncState = 'errored';
-            this.#resolveErrored = true;
-            return this.restoreChain();
-            // console.log(e);
-        }
-    }
-    async restoreChain() {
-        try {
-            const { hash } = await this.#getLatestBlock();
-            await globalThis.chainStore.put('lastBlock', hash);
-            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'));
-            }
-            catch (error) {
-                debug$1(`No local state hash found: ${error}`);
+            if (globalThis.peernet.peers.length === 0) {
+                this.#syncing = false;
+                return 'connectionless';
             }
-            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;
+            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));
             }
-            // 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]));
-                }
-            }
-            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() {
@@ -1479,26 +1294,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>;
     /**
@@ -54,13 +46,11 @@ export default class State extends Contract {
     getLatestBlock(): Promise<BlockMessage['decoded']>;
     getAndPutBlock(hash: string): Promise<BlockMessage>;
     resolveBlock(hash: string): Promise<void>;
-    resolveBlocks(): Promise<any>;
-    restoreChain(): any;
-    syncChain(lastBlock?: any): Promise<SyncState>;
+    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.150",
+  "version": "1.7.152",
   "description": "Official javascript implementation",
   "private": false,
   "exports": {