@leofcoin/chain 1.8.1 → 1.8.3

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, ResolveError, isExecutionError } from '@leofcoin/errors';
+import { ContractDeploymentError, ExecutionError, isResolveError, ResolveError, isExecutionError } from '@leofcoin/errors';
 
 const limit = 1800;
 const transactionLimit = 1000;
@@ -771,34 +771,42 @@ class Jobber {
 
 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 isSyncing() {
-        return this.#syncing;
+    get resolving() {
+        return this.#resolving;
     }
-    // Delegate to machine
     get contracts() {
         return this.#machine.contracts;
     }
@@ -841,38 +849,35 @@ class State extends Contract {
     get lastBlockHeight() {
         return this.#machine ? this.#machine.lastBlockHeight : 0;
     }
-    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);
     }
+    get totalSize() {
+        return this.#totalSize;
+    }
+    get machine() {
+        return this.#machine;
+    }
     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: { syncing: this.#syncing, loaded: this.#loaded }
+                response: this.#chainState
             });
         };
         this.#lastBlockHandler = async () => {
@@ -914,45 +919,67 @@ class State extends Contract {
     #lastBlockHandler;
     #knownBlocksHandler;
     async init() {
-        // Initialize jobber for timed, cancelable tasks
         this.jobber = new Jobber(this.resolveTimeout);
-        // 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));
+        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;
         try {
-            // 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'));
+            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);
                     localBlock = { ...blockMessage.decoded, hash: localBlockHash };
                 }
             }
-            catch (error) {
-                debug$1('No local block found');
+            else {
+                localBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
             }
-            // Load known blocks
-            try {
-                this.knownBlocks = await globalThis.blockStore.keys();
+        }
+        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();
+                }
             }
-            catch (error) {
-                debug$1('No known blocks found');
+            else {
+                await this.resolveBlocks();
             }
-            // 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') {
-                await this.updateState(new BlockMessage(lastBlock));
+                this.updateState(new BlockMessage(lastBlock));
             }
             this.#loaded = true;
+            // await this.#loadBlocks(this.#blocks)
         }
         catch (error) {
-            console.error('Failed to initialize state:', error);
+            console.log('e');
+            if (isResolveError(error)) {
+                console.error(error);
+            }
+            console.log(error);
         }
     }
     async updateState(message) {
@@ -986,47 +1013,41 @@ class State extends Contract {
         return block;
     }
     async #resolveBlock(hash) {
-        if (this.#resolvingBlocks.has(hash)) {
-            return; // Already resolving this block
-        }
-        this.#resolvingBlocks.add(hash);
+        let index = this.#blockHashMap.get(hash);
+        let localHash = '0x0';
         try {
-            let index = this.#blockHashMap.get(hash);
-            debug$1(`resolving block: ${hash} @${index !== undefined ? index : 'unknown'}`);
-            if (this.#blocks[index]) {
-                // Block already exists
+            localHash = await globalThis.stateStore.get('lastBlock');
+        }
+        catch (error) {
+            debug$1('no local state found');
+        }
+        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);
             }
-            const block = await this.getAndPutBlock(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 fetchedResults = await Promise.allSettled(transactionsToFetch.map((txHash) => globalThis.peernet.get(txHash, 'transaction')));
-                // Batch store all transactions that were successfully fetched
-                for (let i = 0; i < fetchedResults.length; i++) {
-                    if (fetchedResults[i].status === 'fulfilled') {
-                        await globalThis.transactionStore.put(transactionsToFetch[i], fetchedResults[i].value);
-                    }
-                    else {
-                        debug$1(`failed to fetch transaction ${transactionsToFetch[i]}: ${fetchedResults[i].reason?.message || fetchedResults[i].reason}`);
-                    }
-                }
+            else {
+                // Previous block already exists or is genesis, stop resolving
+                return;
             }
-            // Remove from pool
-            await Promise.all(transactionHashes.map(async (txHash) => {
-                if (await globalThis.transactionPoolStore.has(txHash)) {
-                    await globalThis.transactionPoolStore.delete(txHash);
+        }
+        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;
             this.#totalSize += size;
             this.#blocks[index] = { hash, ...block.decoded };
             this.#blockHashMap.set(hash, index);
@@ -1036,147 +1057,187 @@ class State extends Contract {
             this.#lastResolvedTime = Date.now();
         }
         catch (error) {
-            throw new ResolveError(`block: ${hash}`);
+            throw new ResolveError(`block: ${hash}@${index}`);
         }
-        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(`Could not fetch block ${currentHash} to determine chain: ${error}`);
-                break;
-            }
-        }
-        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);
+        return;
     }
     async resolveBlock(hash) {
-        if (!hash || hash === '0x0')
-            return;
-        if (this.#syncing)
+        if (!hash)
+            throw new Error(`expected hash, got: ${hash}`);
+        if (hash === '0x0')
             return;
-        this.#syncing = true;
-        this.#syncErrorCount = 0;
+        if (this.#resolving)
+            return 'already resolving';
+        this.#resolving = true;
+        if (this.jobber.busy && this.jobber.destroy)
+            await this.jobber.destroy();
         try {
-            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) {
-                // If a previous resolve job is still running, cancel it
-                if (this.jobber?.busy && this.jobber.destroy)
-                    await this.jobber.destroy();
-                // Run the parallel resolution inside a timed jobber task
-                await this.jobber.add(() => this.#resolveBlocksInParallel(blockChain));
+            await this.jobber.add(() => this.#resolveBlock(hash));
+            this.#resolving = false;
+            const lastBlockHash = await globalThis.stateStore.get('lastBlock');
+            if (lastBlockHash === hash) {
+                this.#resolveErrored = false;
+                return;
             }
+            if (!this.#blockHashMap.has(this.#lastResolved.previousHash) && this.#lastResolved.previousHash !== '0x0')
+                return this.resolveBlock(this.#lastResolved.previousHash);
         }
         catch (error) {
-            console.error('Block resolution failed:', 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);
-        }
-        finally {
-            this.#syncing = false;
+            throw new ResolveError(`block: ${hash}`, { cause: error });
         }
     }
     async resolveBlocks() {
-        if (this.#syncing)
+        // Don't re-resolve if already syncing or resolving
+        if (this.#chainSyncing || this.#resolving) {
+            debug$1('Already syncing or resolving, skipping resolveBlocks()');
             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') {
-                // Cancel any in-flight job before starting a new one
-                if (this.jobber?.busy && this.jobber.destroy)
-                    await this.jobber.destroy();
-                // Build chain and resolve in parallel under jobber control
-                const run = async () => {
-                    const chain = await this.#buildBlockChain(hash);
-                    if (chain.length > 0) {
-                        await this.#resolveBlocksInParallel(chain);
-                    }
-                };
-                await this.jobber.add(run);
+                debug$1(`Resolving blocks from hash: ${hash}`);
+                await this.resolveBlock(hash);
             }
         }
         catch (error) {
-            debug$1('Failed to resolve blocks:', 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);
         }
     }
     async syncChain(lastBlock) {
-        if (this.#syncing)
-            return 'syncing';
+        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 (!lastBlock)
             lastBlock = await this.#getLatestBlock();
-        this.#syncing = true;
+        if (globalThis.peernet.peers.length === 0)
+            return 'connectionless';
         try {
-            if (globalThis.peernet.peers.length === 0) {
-                this.#syncing = false;
-                return 'connectionless';
+            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'));
             }
-            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));
+            catch (error) {
+                debug$1(`No local state hash found: ${error}`);
             }
-            if (blocks.length > 0) {
-                await this.updateState(new BlockMessage(blocks[blocks.length - 1]));
+            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]));
+                }
+            }
+            else {
+                debug$1(`Block already in local state. Remote hash: ${remoteBlockHash} matches local state`);
             }
-            this.#syncErrorCount = 0;
-            this.#syncing = false;
-            return 'synced';
         }
         catch (error) {
-            this.#syncErrorCount++;
-            if (this.#syncErrorCount < 3) {
-                this.#syncing = false;
-                return this.syncChain(lastBlock);
-            }
-            this.#syncErrorCount = 0;
-            this.#syncing = false;
-            return 'errored';
+            console.log(error);
+            throw error;
         }
     }
     async #getLatestBlock() {
@@ -1212,9 +1273,7 @@ class State extends Contract {
         debug$1(`Latest block from peers: ${latest.hash} @${latest.index}`);
         if (latest.hash && latest.hash !== '0x0') {
             let message = await globalThis.peernet.get(latest.hash, 'block');
-            debug$1({ message });
             message = await new BlockMessage(message);
-            debug$1({ message });
             const hash = await message.hash();
             if (hash !== latest.hash)
                 throw new Error('invalid block @getLatestBlock');
@@ -1227,7 +1286,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.wantList.push(...message.decoded.response);
+                this.wantList.push(...message.decoded.response.blocks.filter((block) => !this.knownBlocks.includes(block)));
             }
         }
         return latest;
@@ -1347,13 +1406,26 @@ class State extends Contract {
         });
     }
     get canSync() {
-        return !this.#syncing;
+        if (this.#chainSyncing)
+            return false;
+        return true;
     }
     get shouldSync() {
-        if (this.#syncing)
+        if (this.#chainSyncing)
             return false;
+        // Check if we have any connected peers with the same version
         const compatiblePeers = Object.values(globalThis.peernet.connections || {}).filter((peer) => peer.connected && peer.version === this.version);
-        return compatiblePeers.length > 0;
+        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;
     }
     async #waitForPeers(timeoutMs = 30000) {
         return new Promise((resolve) => {