@leofcoin/chain 1.4.74 → 1.4.76

package/exports/browser/chain.js

@@ -1818,11 +1818,38 @@ class Machine {
     }
 }
 
-const queue = new PQueue({ concurrency: 1, throwOnTimeout: true });
+class Jobber {
+    timeout;
+    busy = false;
+    stop;
+    constructor(timeout) {
+        this.timeout = timeout;
+    }
+    add(fn) {
+        this.busy = true;
+        return new Promise(async (resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject('timeout');
+            }, this.timeout);
+            this.stop = () => {
+                clearTimeout(timeout);
+                this.busy = false;
+                resolve('stopped');
+            };
+            const result = await fn();
+            clearTimeout(timeout);
+            this.busy = false;
+            resolve(result);
+        });
+    }
+}
+
+new PQueue({ concurrency: 1, throwOnTimeout: true });
 class State extends Contract {
     #resolveErrored;
     #lastResolvedTime;
     #lastResolved;
+    #resolving = false;
     #resolveErrorCount = 0;
     #syncState;
     #lastBlockInQue;
@@ -1831,9 +1858,16 @@ class State extends Contract {
     #chainSyncing = false;
     #lastBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
     #blocks = [];
-    #knownBlocks = [];
+    knownBlocks = [];
     #totalSize = 0;
     #machine;
+    #loaded = false;
+    get loaded() {
+        return this.#loaded;
+    }
+    get resolving() {
+        return this.#resolving;
+    }
     /**
      * amount the native token has been iteracted with
      */
@@ -1888,6 +1922,7 @@ class State extends Contract {
         super();
     }
     async init() {
+        this.jobber = new Jobber(30_000);
         if (super.init)
             await super.init();
         await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
@@ -1960,38 +1995,69 @@ class State extends Contract {
                 return;
             }
         }
-        const block = await this.getAndPutBlock(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);
-        globalThis.debug(`resolved block: ${hash} @${index} ${formatBytes(size)}`);
-        this.#lastResolved = this.#blocks[index];
-        this.#lastResolvedTime = Date.now();
+        try {
+            const block = await this.getAndPutBlock(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);
+            globalThis.debug(`resolved block: ${hash} @${index} ${formatBytes(size)}`);
+            this.#lastResolved = this.#blocks[index];
+            this.#lastResolvedTime = Date.now();
+        }
+        catch (error) {
+            this.#resolving = false;
+            this.#chainSyncing = false;
+            throw new Error('resolve error');
+        }
         return;
     }
     async resolveBlock(hash) {
+        if (this.#resolveErrorCount === 3)
+            this.#resolveErrorCount = 0;
         if (!hash)
             throw new Error(`expected hash, got: ${hash}`);
         if (hash === '0x0')
             return;
-        await queue.add(() => this.#resolveBlock(hash));
-        if (!this.#blockHashMap.has(this.#lastResolved.previousHash) && this.#lastResolved.previousHash !== '0x0')
-            return this.resolveBlock(this.#lastResolved.previousHash);
-        return;
+        if (this.#resolving)
+            return 'already resolving';
+        this.#resolving = true;
+        try {
+            await this.jobber.add(() => this.#resolveBlock(hash));
+            this.#resolving = false;
+            if (!this.#blockHashMap.has(this.#lastResolved.previousHash) && this.#lastResolved.previousHash !== '0x0')
+                return this.resolveBlock(this.#lastResolved.previousHash);
+        }
+        catch (error) {
+            this.#resolveErrorCount += 1;
+            if (this.#resolveErrorCount < 3)
+                return this.resolveBlock(hash);
+            else
+                throw new Error('resolve errored');
+        }
     }
     async resolveBlocks() {
+        try {
+            if (this.jobber.busy && this.jobber.stop) {
+                await this.jobber.stop();
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
         try {
             const localBlock = await globalThis.chainStore.get('lastBlock');
             const hash = new TextDecoder().decode(localBlock);
-            if (hash && hash !== '0x0')
+            if (hash && hash !== '0x0') {
                 await this.resolveBlock(hash);
-            this.#lastBlock = this.#blocks[this.#blocks.length - 1];
+                this.#lastBlock = this.#blocks[this.#blocks.length - 1];
+            }
         }
         catch {
             this.#resolveErrored = true;
             this.#resolveErrorCount += 1;
+            this.#resolving = false;
             // console.log(e);
         }
     }
@@ -1999,7 +2065,15 @@ class State extends Contract {
         if (!this.shouldSync) {
             return;
         }
-        await queue.clear();
+        try {
+            if (this.jobber.busy && this.jobber.stop) {
+                await this.jobber.stop();
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+        // await queue.clear()
         this.#chainSyncing = true;
         if (!lastBlock)
             lastBlock = await this.#getLatestBlock();
@@ -2027,9 +2101,9 @@ class State extends Contract {
     }
     async #syncChain(lastBlock) {
         try {
-            if (this.#knownBlocks?.length === Number(lastBlock.index) + 1) {
+            if (this.knownBlocks?.length === Number(lastBlock.index) + 1) {
                 let promises = [];
-                promises = await Promise.allSettled(this.#knownBlocks.map(async (address) => {
+                promises = await Promise.allSettled(this.knownBlocks.map(async (address) => {
                     const has = await globalThis.peernet.has(address, 'block');
                     return { has, address };
                 }));
@@ -2061,15 +2135,16 @@ class State extends Contract {
         let node = await globalThis.peernet.prepareMessage(data);
         for (const peer of globalThis.peernet?.connections) {
             if (peer.connected && peer.version === this.version) {
-                promises.push(async () => {
+                const task = async () => {
                     try {
                         const result = await peer.request(node.encoded);
-                        return { result, peer };
+                        return { result: Uint8Array.from(Object.values(result)), peer };
                     }
                     catch (error) {
                         throw error;
                     }
-                });
+                };
+                promises.push(task());
             }
         }
         promises = await this.promiseRequests(promises);
@@ -2090,7 +2165,7 @@ class State extends Contract {
                 let node = await globalThis.peernet.prepareMessage(data);
                 let message = await peer.request(node);
                 message = await new globalThis.peernet.protos['peernet-response'](message);
-                this.#knownBlocks = message.decoded.response;
+                this.knownBlocks = message.decoded.response;
             }
         }
         return latest;
@@ -2103,6 +2178,8 @@ class State extends Contract {
         let poolTransactionKeys = await globalThis.transactionPoolStore.keys();
         for (const block of blocks) {
             if (block && !block.loaded) {
+                if (block.index === 0)
+                    this.#loaded = true;
                 for (const transaction of block.transactions) {
                     if (poolTransactionKeys.includes(transaction.hash))
                         await globalThis.transactionPoolStore.delete(transaction.hash);
@@ -2141,7 +2218,8 @@ class State extends Contract {
             clearTimeout(timeout);
             if (promises.length > 0) {
                 promises = promises.map(async ({ value }) => {
-                    const node = await new globalThis.peernet.protos['peernet-response'](value);
+                    console.log(value);
+                    const node = await new globalThis.peernet.protos['peernet-response'](value.result);
                     return { value: node.decoded.response, peer: value.peer };
                 });
                 promises = await Promise.all(promises);
@@ -2319,8 +2397,8 @@ class Chain extends State {
             return;
         const lastBlock = await this.#makeRequest(peer, 'lastBlock');
         if (Object.keys(lastBlock).length > 0) {
-            if (!this.lastBlock || !this.blocks[this.blocks.length - 1].loaded || lastBlock && lastBlock.index > this.lastBlock?.index) {
-                // this.#knownBlocks = await this.#makeRequest(peer, 'knownBlocks')
+            if (!this.lastBlock || !this.blocks[this.blocks.length - 1]?.loaded || lastBlock && lastBlock.index > this.lastBlock?.index || !this.loaded && !this.resolving) {
+                this.knownBlocks = await this.#makeRequest(peer, 'knownBlocks');
                 await this.syncChain(lastBlock);
                 // if (await this.hasTransactionToHandle() && this.#participating) this.#runEpoch()
             }

package/exports/chain.js

@@ -444,11 +444,38 @@ class Machine {
     }
 }
 
-const queue = new PQueue({ concurrency: 1, throwOnTimeout: true });
+class Jobber {
+    timeout;
+    busy = false;
+    stop;
+    constructor(timeout) {
+        this.timeout = timeout;
+    }
+    add(fn) {
+        this.busy = true;
+        return new Promise(async (resolve, reject) => {
+            const timeout = setTimeout(() => {
+                reject('timeout');
+            }, this.timeout);
+            this.stop = () => {
+                clearTimeout(timeout);
+                this.busy = false;
+                resolve('stopped');
+            };
+            const result = await fn();
+            clearTimeout(timeout);
+            this.busy = false;
+            resolve(result);
+        });
+    }
+}
+
+new PQueue({ concurrency: 1, throwOnTimeout: true });
 class State extends Contract {
     #resolveErrored;
     #lastResolvedTime;
     #lastResolved;
+    #resolving = false;
     #resolveErrorCount = 0;
     #syncState;
     #lastBlockInQue;
@@ -457,9 +484,16 @@ class State extends Contract {
     #chainSyncing = false;
     #lastBlock = { index: 0, hash: '0x0', previousHash: '0x0' };
     #blocks = [];
-    #knownBlocks = [];
+    knownBlocks = [];
     #totalSize = 0;
     #machine;
+    #loaded = false;
+    get loaded() {
+        return this.#loaded;
+    }
+    get resolving() {
+        return this.#resolving;
+    }
     /**
      * amount the native token has been iteracted with
      */
@@ -514,6 +548,7 @@ class State extends Contract {
         super();
     }
     async init() {
+        this.jobber = new Jobber(30_000);
         if (super.init)
             await super.init();
         await globalThis.peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
@@ -586,38 +621,69 @@ class State extends Contract {
                 return;
             }
         }
-        const block = await this.getAndPutBlock(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);
-        globalThis.debug(`resolved block: ${hash} @${index} ${formatBytes(size)}`);
-        this.#lastResolved = this.#blocks[index];
-        this.#lastResolvedTime = Date.now();
+        try {
+            const block = await this.getAndPutBlock(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);
+            globalThis.debug(`resolved block: ${hash} @${index} ${formatBytes(size)}`);
+            this.#lastResolved = this.#blocks[index];
+            this.#lastResolvedTime = Date.now();
+        }
+        catch (error) {
+            this.#resolving = false;
+            this.#chainSyncing = false;
+            throw new Error('resolve error');
+        }
         return;
     }
     async resolveBlock(hash) {
+        if (this.#resolveErrorCount === 3)
+            this.#resolveErrorCount = 0;
         if (!hash)
             throw new Error(`expected hash, got: ${hash}`);
         if (hash === '0x0')
             return;
-        await queue.add(() => this.#resolveBlock(hash));
-        if (!this.#blockHashMap.has(this.#lastResolved.previousHash) && this.#lastResolved.previousHash !== '0x0')
-            return this.resolveBlock(this.#lastResolved.previousHash);
-        return;
+        if (this.#resolving)
+            return 'already resolving';
+        this.#resolving = true;
+        try {
+            await this.jobber.add(() => this.#resolveBlock(hash));
+            this.#resolving = false;
+            if (!this.#blockHashMap.has(this.#lastResolved.previousHash) && this.#lastResolved.previousHash !== '0x0')
+                return this.resolveBlock(this.#lastResolved.previousHash);
+        }
+        catch (error) {
+            this.#resolveErrorCount += 1;
+            if (this.#resolveErrorCount < 3)
+                return this.resolveBlock(hash);
+            else
+                throw new Error('resolve errored');
+        }
     }
     async resolveBlocks() {
+        try {
+            if (this.jobber.busy && this.jobber.stop) {
+                await this.jobber.stop();
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
         try {
             const localBlock = await globalThis.chainStore.get('lastBlock');
             const hash = new TextDecoder().decode(localBlock);
-            if (hash && hash !== '0x0')
+            if (hash && hash !== '0x0') {
                 await this.resolveBlock(hash);
-            this.#lastBlock = this.#blocks[this.#blocks.length - 1];
+                this.#lastBlock = this.#blocks[this.#blocks.length - 1];
+            }
         }
         catch {
             this.#resolveErrored = true;
             this.#resolveErrorCount += 1;
+            this.#resolving = false;
             // console.log(e);
         }
     }
@@ -625,7 +691,15 @@ class State extends Contract {
         if (!this.shouldSync) {
             return;
         }
-        await queue.clear();
+        try {
+            if (this.jobber.busy && this.jobber.stop) {
+                await this.jobber.stop();
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+        // await queue.clear()
         this.#chainSyncing = true;
         if (!lastBlock)
             lastBlock = await this.#getLatestBlock();
@@ -653,9 +727,9 @@ class State extends Contract {
     }
     async #syncChain(lastBlock) {
         try {
-            if (this.#knownBlocks?.length === Number(lastBlock.index) + 1) {
+            if (this.knownBlocks?.length === Number(lastBlock.index) + 1) {
                 let promises = [];
-                promises = await Promise.allSettled(this.#knownBlocks.map(async (address) => {
+                promises = await Promise.allSettled(this.knownBlocks.map(async (address) => {
                     const has = await globalThis.peernet.has(address, 'block');
                     return { has, address };
                 }));
@@ -687,15 +761,16 @@ class State extends Contract {
         let node = await globalThis.peernet.prepareMessage(data);
         for (const peer of globalThis.peernet?.connections) {
             if (peer.connected && peer.version === this.version) {
-                promises.push(async () => {
+                const task = async () => {
                     try {
                         const result = await peer.request(node.encoded);
-                        return { result, peer };
+                        return { result: Uint8Array.from(Object.values(result)), peer };
                     }
                     catch (error) {
                         throw error;
                     }
-                });
+                };
+                promises.push(task());
             }
         }
         promises = await this.promiseRequests(promises);
@@ -716,7 +791,7 @@ class State extends Contract {
                 let node = await globalThis.peernet.prepareMessage(data);
                 let message = await peer.request(node);
                 message = await new globalThis.peernet.protos['peernet-response'](message);
-                this.#knownBlocks = message.decoded.response;
+                this.knownBlocks = message.decoded.response;
             }
         }
         return latest;
@@ -729,6 +804,8 @@ class State extends Contract {
         let poolTransactionKeys = await globalThis.transactionPoolStore.keys();
         for (const block of blocks) {
             if (block && !block.loaded) {
+                if (block.index === 0)
+                    this.#loaded = true;
                 for (const transaction of block.transactions) {
                     if (poolTransactionKeys.includes(transaction.hash))
                         await globalThis.transactionPoolStore.delete(transaction.hash);
@@ -767,7 +844,8 @@ class State extends Contract {
             clearTimeout(timeout);
             if (promises.length > 0) {
                 promises = promises.map(async ({ value }) => {
-                    const node = await new globalThis.peernet.protos['peernet-response'](value);
+                    console.log(value);
+                    const node = await new globalThis.peernet.protos['peernet-response'](value.result);
                     return { value: node.decoded.response, peer: value.peer };
                 });
                 promises = await Promise.all(promises);
@@ -945,8 +1023,8 @@ class Chain extends State {
             return;
         const lastBlock = await this.#makeRequest(peer, 'lastBlock');
         if (Object.keys(lastBlock).length > 0) {
-            if (!this.lastBlock || !this.blocks[this.blocks.length - 1].loaded || lastBlock && lastBlock.index > this.lastBlock?.index) {
-                // this.#knownBlocks = await this.#makeRequest(peer, 'knownBlocks')
+            if (!this.lastBlock || !this.blocks[this.blocks.length - 1]?.loaded || lastBlock && lastBlock.index > this.lastBlock?.index || !this.loaded && !this.resolving) {
+                this.knownBlocks = await this.#makeRequest(peer, 'knownBlocks');
                 await this.syncChain(lastBlock);
                 // if (await this.hasTransactionToHandle() && this.#participating) this.#runEpoch()
             }

package/exports/typings/jobs/jobber.d.ts

@@ -0,0 +1,7 @@
+export default class Jobber {
+    timeout: EpochTimeStamp;
+    busy: boolean;
+    stop: Function;
+    constructor(timeout: any);
+    add(fn: any): Promise<unknown>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/chain",
-  "version": "1.4.74",
+  "version": "1.4.76",
   "description": "Official javascript implementation",
   "exports": {
     "./node": "./exports/node.js",

package/exports/typings/jobs/sync.d.ts

@@ -1,3 +0,0 @@
-export default class SyncJob {
-    constructor();
-}