@leofcoin/chain 1.7.152 → 1.7.154

package/exports/browser/chain.js

@@ -4189,7 +4189,7 @@ class Machine {
                 break;
             }
             case 'debug': {
-                debug$2(data.message);
+                // debug(data.message)
                 if (data.message.includes('loaded transactions for block:')) {
                     pubsub.publish('block-loaded', data.message.replace('loaded transactions for block: ', '').split(' @')[0]);
                 }
@@ -4598,6 +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 {
     #blockHashMap;
@@ -4610,6 +4640,7 @@ class State extends Contract {
     // Block resolution state
     #resolvingBlocks;
     #maxConcurrentResolves;
+    #txConcurrency;
     #totalSize;
     #lastResolved;
     #lastResolvedTime;
@@ -4696,6 +4727,7 @@ class State extends Contract {
         // Block resolution state
         this.#resolvingBlocks = new Set();
         this.#maxConcurrentResolves = 10;
+        this.#txConcurrency = 25;
         this.knownBlocks = [];
         this.#totalSize = 0;
         this._wantList = [];
@@ -4743,6 +4775,8 @@ 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));
@@ -4862,6 +4896,52 @@ class State extends Contract {
             this.#resolvingBlocks.delete(hash);
         }
     }
+    // Small utility to keep event loop responsive
+    async #sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    // Run a list of tasks with bounded concurrency
+    async #runWithConcurrency(items, concurrency, handler) {
+        let index = 0;
+        const total = items.length;
+        const worker = async () => {
+            while (true) {
+                const current = index++;
+                if (current >= total)
+                    break;
+                try {
+                    await handler(items[current], current);
+                    if (current % 50 === 0)
+                        debug$1(`executed ${current}/${total}`);
+                }
+                catch (e) {
+                    debug$1(`transaction handler error at ${current}: ${e}`);
+                }
+                // yield a tick every few ops to avoid blocking
+                if (current % 25 === 0)
+                    await this.#sleep(1);
+            }
+        };
+        const workers = Array.from({ length: Math.min(concurrency, Math.max(1, total)) }, () => worker());
+        await Promise.all(workers);
+    }
+    // Execute a single transaction with a timeout to avoid indefinite hangs
+    async #executeWithTimeout(transaction, timeoutMs) {
+        const timeout = timeoutMs ?? this.resolveTimeout ?? 5000;
+        let timer;
+        try {
+            return await Promise.race([
+                this.#machine.execute(transaction.decoded.to, transaction.decoded.method, transaction.decoded.params),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error('transaction execution timeout')), timeout);
+                })
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
     async #buildBlockChain(latestHash, maxBlocks = 1000) {
         const chain = [];
         let currentHash = latestHash;
@@ -4924,7 +5004,11 @@ class State extends Contract {
             const blockChain = await this.#buildBlockChain(hash);
             debug$1(`Built chain of ${blockChain.length} blocks`);
             if (blockChain.length > 0) {
-                await this.#resolveBlocksInParallel(blockChain);
+                // 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));
             }
         }
         catch (error) {
@@ -4942,7 +5026,17 @@ class State extends Contract {
             const localBlock = await globalThis.chainStore.get('lastBlock');
             const hash = new TextDecoder().decode(localBlock);
             if (hash && hash !== '0x0') {
-                await this.resolveBlock(hash);
+                // 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);
             }
         }
         catch (error) {
@@ -5043,7 +5137,7 @@ class State extends Contract {
     // todo throw error
     async #_executeTransaction(transaction) {
         try {
-            await this.#machine.execute(transaction.decoded.to, transaction.decoded.method, transaction.decoded.params);
+            await this.#executeWithTimeout(transaction);
             // await globalThis.accountsStore.put(transaction.decoded.from, String(transaction.decoded.nonce))
             // if (transaction.decoded.to === nativeToken) {
             //   this.#nativeCalls += 1
@@ -5109,7 +5203,8 @@ class State extends Contract {
                     }
                     transactions = transactions.filter((transaction) => !transaction.decoded.priority);
                     debug$1(`executing ${transactions.length} transactions for block ${block.index}`);
-                    await Promise.all(transactions.map((transaction) => this.#_executeTransaction(transaction)));
+                    // Concurrency-limited execution to avoid blocking on large blocks
+                    await this.#runWithConcurrency(transactions, this.#txConcurrency, async (tx) => this.#_executeTransaction(tx));
                     this.#blocks[block.index].loaded = true;
                     debug$1(`executed transactions for block ${block.index}`);
                     if (Number(block.index) === 0)

package/exports/chain.js

@@ -330,7 +330,7 @@ class Machine {
                 break;
             }
             case 'debug': {
-                debug$2(data.message);
+                // debug(data.message)
                 if (data.message.includes('loaded transactions for block:')) {
                     pubsub.publish('block-loaded', data.message.replace('loaded transactions for block: ', '').split(' @')[0]);
                 }
@@ -739,6 +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 {
     #blockHashMap;
@@ -751,6 +781,7 @@ class State extends Contract {
     // Block resolution state
     #resolvingBlocks;
     #maxConcurrentResolves;
+    #txConcurrency;
     #totalSize;
     #lastResolved;
     #lastResolvedTime;
@@ -837,6 +868,7 @@ class State extends Contract {
         // Block resolution state
         this.#resolvingBlocks = new Set();
         this.#maxConcurrentResolves = 10;
+        this.#txConcurrency = 25;
         this.knownBlocks = [];
         this.#totalSize = 0;
         this._wantList = [];
@@ -884,6 +916,8 @@ 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));
@@ -1003,6 +1037,52 @@ class State extends Contract {
             this.#resolvingBlocks.delete(hash);
         }
     }
+    // Small utility to keep event loop responsive
+    async #sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    // Run a list of tasks with bounded concurrency
+    async #runWithConcurrency(items, concurrency, handler) {
+        let index = 0;
+        const total = items.length;
+        const worker = async () => {
+            while (true) {
+                const current = index++;
+                if (current >= total)
+                    break;
+                try {
+                    await handler(items[current], current);
+                    if (current % 50 === 0)
+                        debug$1(`executed ${current}/${total}`);
+                }
+                catch (e) {
+                    debug$1(`transaction handler error at ${current}: ${e}`);
+                }
+                // yield a tick every few ops to avoid blocking
+                if (current % 25 === 0)
+                    await this.#sleep(1);
+            }
+        };
+        const workers = Array.from({ length: Math.min(concurrency, Math.max(1, total)) }, () => worker());
+        await Promise.all(workers);
+    }
+    // Execute a single transaction with a timeout to avoid indefinite hangs
+    async #executeWithTimeout(transaction, timeoutMs) {
+        const timeout = timeoutMs ?? this.resolveTimeout ?? 5000;
+        let timer;
+        try {
+            return await Promise.race([
+                this.#machine.execute(transaction.decoded.to, transaction.decoded.method, transaction.decoded.params),
+                new Promise((_, reject) => {
+                    timer = setTimeout(() => reject(new Error('transaction execution timeout')), timeout);
+                })
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
     async #buildBlockChain(latestHash, maxBlocks = 1000) {
         const chain = [];
         let currentHash = latestHash;
@@ -1065,7 +1145,11 @@ class State extends Contract {
             const blockChain = await this.#buildBlockChain(hash);
             debug$1(`Built chain of ${blockChain.length} blocks`);
             if (blockChain.length > 0) {
-                await this.#resolveBlocksInParallel(blockChain);
+                // 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));
             }
         }
         catch (error) {
@@ -1083,7 +1167,17 @@ class State extends Contract {
             const localBlock = await globalThis.chainStore.get('lastBlock');
             const hash = new TextDecoder().decode(localBlock);
             if (hash && hash !== '0x0') {
-                await this.resolveBlock(hash);
+                // 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);
             }
         }
         catch (error) {
@@ -1184,7 +1278,7 @@ class State extends Contract {
     // todo throw error
     async #_executeTransaction(transaction) {
         try {
-            await this.#machine.execute(transaction.decoded.to, transaction.decoded.method, transaction.decoded.params);
+            await this.#executeWithTimeout(transaction);
             // await globalThis.accountsStore.put(transaction.decoded.from, String(transaction.decoded.nonce))
             // if (transaction.decoded.to === nativeToken) {
             //   this.#nativeCalls += 1
@@ -1250,7 +1344,8 @@ class State extends Contract {
                     }
                     transactions = transactions.filter((transaction) => !transaction.decoded.priority);
                     debug$1(`executing ${transactions.length} transactions for block ${block.index}`);
-                    await Promise.all(transactions.map((transaction) => this.#_executeTransaction(transaction)));
+                    // Concurrency-limited execution to avoid blocking on large blocks
+                    await this.#runWithConcurrency(transactions, this.#txConcurrency, async (tx) => this.#_executeTransaction(tx));
                     this.#blocks[block.index].loaded = true;
                     debug$1(`executed transactions for block ${block.index}`);
                     if (Number(block.index) === 0)

package/exports/state.d.ts

@@ -1,9 +1,11 @@
 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';
 export default class State extends Contract {
     #private;
+    jobber: Jobber;
     knownBlocks: BlockHash[];
     _wantList: any[];
     /**

package/package.json

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