@leofcoin/chain 1.7.149 → 1.7.150

package/exports/browser/chain.js

@@ -4646,6 +4646,9 @@ class State extends Contract {
     #totalSize;
     #machine;
     #loaded;
+    #resolvingBlocks;
+    #maxConcurrentResolves;
+    #blockResolveQueue;
     /**
      * contains transactions we need before we can successfully load
      */
@@ -4735,6 +4738,9 @@ class State extends Contract {
         this.#totalSize = 0;
         this.#loaded = false;
         this._wantList = [];
+        this.#resolvingBlocks = new Set();
+        this.#maxConcurrentResolves = 10;
+        this.#blockResolveQueue = [];
         this.#chainStateHandler = () => {
             return new globalThis.peernet.protos['peernet-response']({
                 response: this.#chainState
@@ -4873,45 +4879,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);
@@ -4921,42 +4922,103 @@ class State extends Contract {
             this.#lastResolvedTime = Date.now();
         }
         catch (error) {
-            throw new ResolveError(`block: ${hash}@${index}`);
+            throw new ResolveError(`block: ${hash}`);
         }
-        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(`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);
     }
     async resolveBlock(hash) {
         if (!hash)
             throw new Error(`expected hash, got: ${hash}`);
         if (hash === '0x0')
             return;
-        if (this.#resolving)
-            return 'already resolving';
+        if (this.#resolving) {
+            debug$1('Already resolving, queueing block');
+            return;
+        }
         this.#resolving = true;
-        if (this.jobber.busy && this.jobber.destroy)
-            await this.jobber.destroy();
         try {
-            await this.jobber.add(() => this.#resolveBlock(hash));
+            // 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) {
-                    this.#resolveErrored = false;
+                    debug$1('Resolved to latest block state');
                     return;
                 }
             }
             catch (error) {
                 debug$1('no local state found');
             }
-            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)
+            if (this.#resolveErrorCount < 3) {
+                debug$1(`Retry ${this.#resolveErrorCount}/3 for block ${hash}`);
                 return this.resolveBlock(hash);
+            }
             this.#resolveErrorCount = 0;
             this.wantList.push(hash);
             throw new ResolveError(`block: ${hash}`, { cause: error });
@@ -5157,7 +5219,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;

package/exports/chain.js

@@ -786,6 +786,9 @@ class State extends Contract {
     #totalSize;
     #machine;
     #loaded;
+    #resolvingBlocks;
+    #maxConcurrentResolves;
+    #blockResolveQueue;
     /**
      * contains transactions we need before we can successfully load
      */
@@ -875,6 +878,9 @@ class State extends Contract {
         this.#totalSize = 0;
         this.#loaded = false;
         this._wantList = [];
+        this.#resolvingBlocks = new Set();
+        this.#maxConcurrentResolves = 10;
+        this.#blockResolveQueue = [];
         this.#chainStateHandler = () => {
             return new globalThis.peernet.protos['peernet-response']({
                 response: this.#chainState
@@ -1013,45 +1019,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,42 +1062,103 @@ class State extends Contract {
             this.#lastResolvedTime = Date.now();
         }
         catch (error) {
-            throw new ResolveError(`block: ${hash}@${index}`);
+            throw new ResolveError(`block: ${hash}`);
+        }
+        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;
+        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 resolveBlock(hash) {
         if (!hash)
             throw new Error(`expected hash, got: ${hash}`);
         if (hash === '0x0')
             return;
-        if (this.#resolving)
-            return 'already resolving';
+        if (this.#resolving) {
+            debug$1('Already resolving, queueing block');
+            return;
+        }
         this.#resolving = true;
-        if (this.jobber.busy && this.jobber.destroy)
-            await this.jobber.destroy();
         try {
-            await this.jobber.add(() => this.#resolveBlock(hash));
+            // 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) {
-                    this.#resolveErrored = false;
+                    debug$1('Resolved to latest block state');
                     return;
                 }
             }
             catch (error) {
                 debug$1('no local state found');
             }
-            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)
+            if (this.#resolveErrorCount < 3) {
+                debug$1(`Retry ${this.#resolveErrorCount}/3 for block ${hash}`);
                 return this.resolveBlock(hash);
+            }
             this.#resolveErrorCount = 0;
             this.wantList.push(hash);
             throw new ResolveError(`block: ${hash}`, { cause: error });
@@ -1297,7 +1359,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;

package/exports/state.d.ts

@@ -53,7 +53,7 @@ export default class State extends Contract {
     updateState(message: BlockMessage): Promise<void>;
     getLatestBlock(): Promise<BlockMessage['decoded']>;
     getAndPutBlock(hash: string): Promise<BlockMessage>;
-    resolveBlock(hash: any): any;
+    resolveBlock(hash: string): Promise<void>;
     resolveBlocks(): Promise<any>;
     restoreChain(): any;
     syncChain(lastBlock?: any): Promise<SyncState>;

package/package.json

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