@leofcoin/workers 1.2.4 → 1.2.5

package/dist/bundle/commonjs/{machine-worker-237898fd.js → machine-worker-d1df2d67.js}

@@ -142,29 +142,36 @@ const _init = async ({ contracts, blocks, peerid })=> {
     return contract
   }));
 
-  const _worker = await new worker$1.EasyWorker(require$$1.join(__dirname, './block-worker.js'), {serialization: 'advanced', type: 'module' });
-  blocks = await _worker.once(blocks);
-  
-  for (const block of blocks) {
-    await Promise.all(block.decoded.transactions.map(async message => {
-      const {from, to, method, params} = message;
-      globalThis.msg = createMessage(from);
+  let lastBlock = {hash: '0x0'}; 
+
+  if (blocks?.length > 0) {
+    const _worker = await new worker$1.EasyWorker(require$$1.join(__dirname, './block-worker.js'), {serialization: 'advanced', type: 'module' });
+    blocks = await _worker.once(blocks);
+    
+    for (const block of blocks) {
+      await Promise.all(block.decoded.transactions.map(async message => {
+        const {from, to, method, params} = message;
+        globalThis.msg = createMessage(from);
+      
+        await execute(to, method, params);
+      }));
+    }
     
-      await execute(to, method, params);
-    }));
+    if (blocks.length > 0) {
+      lastBlock = blocks[blocks.length - 1].decoded;    
+      lastBlock = await new utils.BlockMessage(lastBlock);
+  
+      lastBlock = {
+        ...lastBlock.decoded,
+        hash: await lastBlock.hash
+      };
+    }
   }
 
-  let lastBlock;
-  if (blocks.length > 0) {
-    lastBlock = blocks[blocks.length - 1].decoded;    
-    lastBlock = await new utils.BlockMessage(lastBlock);
+  
 
-    lastBlock = {
-      ...lastBlock.decoded,
-      hash: await lastBlock.hash
-    };
-  }
-  worker.postMessage({type: 'machine-ready', lastBlock });
+  
+  worker.postMessage({type: 'machine-ready', lastBlock});
   _worker.terminate(); 
   
   worker.postMessage(blocks);
@@ -172,14 +179,33 @@ const _init = async ({ contracts, blocks, peerid })=> {
 
 const tasks = async (e) => {
   const id = e.id;
-    if (e.type === 'init') await _init(e.input);
+    if (e.type === 'init') {
+      try {
+        await _init(e.input);
+      } catch (e) {
+        worker.postMessage({
+          type: 'initError',
+          message: e.message,
+          id          
+        });
+      }
+    }
     if (e.type === 'get') {
-      const value = await get(e.input.contract, e.input.method, e.input.params);
-      worker.postMessage({
-        type: 'response',
-        id,
-        value
-      });
+      try {
+        const value = await get(e.input.contract, e.input.method, e.input.params);
+        worker.postMessage({
+          type: 'response',
+          id,
+          value
+        });
+      } catch (e) {
+        worker.postMessage({
+          type: 'fetchError',
+          message: e.message,
+          id          
+        });
+      }
+      
     }
     if (e.type === 'execute') {
       try {

package/dist/bundle/commonjs/machine-worker.js

@@ -1,6 +1,6 @@
 'use strict';
 
-require('./machine-worker-237898fd.js');
+require('./machine-worker-d1df2d67.js');
 require('./worker-6ace445f.js');
 require('./utils-6e881be4.js');
 require('path');

package/dist/bundle/commonjs/workers.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var transactionWorker = require('./transaction-worker-176a5aaa.js');
 var blockWorker = require('./block-worker-21ad8152.js');
 var poolWorker = require('./pool-worker-f450eeff.js');
-var machineWorker = require('./machine-worker-237898fd.js');
+var machineWorker = require('./machine-worker-d1df2d67.js');
 require('./worker-6ace445f.js');
 require('stream');
 require('events');

package/dist/bundle/module/{machine-worker-5740c3e5.js → machine-worker-63056a0b.js}

@@ -140,29 +140,36 @@ const _init = async ({ contracts, blocks, peerid })=> {
     return contract
   }));
 
-  const _worker = await new EasyWorker(join(__dirname, './block-worker.js'), {serialization: 'advanced', type: 'module' });
-  blocks = await _worker.once(blocks);
-  
-  for (const block of blocks) {
-    await Promise.all(block.decoded.transactions.map(async message => {
-      const {from, to, method, params} = message;
-      globalThis.msg = createMessage(from);
+  let lastBlock = {hash: '0x0'}; 
+
+  if (blocks?.length > 0) {
+    const _worker = await new EasyWorker(join(__dirname, './block-worker.js'), {serialization: 'advanced', type: 'module' });
+    blocks = await _worker.once(blocks);
+    
+    for (const block of blocks) {
+      await Promise.all(block.decoded.transactions.map(async message => {
+        const {from, to, method, params} = message;
+        globalThis.msg = createMessage(from);
+      
+        await execute(to, method, params);
+      }));
+    }
     
-      await execute(to, method, params);
-    }));
+    if (blocks.length > 0) {
+      lastBlock = blocks[blocks.length - 1].decoded;    
+      lastBlock = await new BlockMessage(lastBlock);
+  
+      lastBlock = {
+        ...lastBlock.decoded,
+        hash: await lastBlock.hash
+      };
+    }
   }
 
-  let lastBlock;
-  if (blocks.length > 0) {
-    lastBlock = blocks[blocks.length - 1].decoded;    
-    lastBlock = await new BlockMessage(lastBlock);
+  
 
-    lastBlock = {
-      ...lastBlock.decoded,
-      hash: await lastBlock.hash
-    };
-  }
-  worker.postMessage({type: 'machine-ready', lastBlock });
+  
+  worker.postMessage({type: 'machine-ready', lastBlock});
   _worker.terminate(); 
   
   worker.postMessage(blocks);
@@ -170,14 +177,33 @@ const _init = async ({ contracts, blocks, peerid })=> {
 
 const tasks = async (e) => {
   const id = e.id;
-    if (e.type === 'init') await _init(e.input);
+    if (e.type === 'init') {
+      try {
+        await _init(e.input);
+      } catch (e) {
+        worker.postMessage({
+          type: 'initError',
+          message: e.message,
+          id          
+        });
+      }
+    }
     if (e.type === 'get') {
-      const value = await get(e.input.contract, e.input.method, e.input.params);
-      worker.postMessage({
-        type: 'response',
-        id,
-        value
-      });
+      try {
+        const value = await get(e.input.contract, e.input.method, e.input.params);
+        worker.postMessage({
+          type: 'response',
+          id,
+          value
+        });
+      } catch (e) {
+        worker.postMessage({
+          type: 'fetchError',
+          message: e.message,
+          id          
+        });
+      }
+      
     }
     if (e.type === 'execute') {
       try {

package/dist/bundle/module/machine-worker.js

@@ -1,4 +1,4 @@
-import './machine-worker-5740c3e5.js';
+import './machine-worker-63056a0b.js';
 import './worker-def77c26.js';
 import './utils-ac8c68e6.js';
 import 'path';

package/dist/bundle/module/workers.js

@@ -1,7 +1,7 @@
 import { t as transactionWorker } from './transaction-worker-548cd200.js';
 import { b as blockWorker } from './block-worker-414860e0.js';
 import { p as poolWorker } from './pool-worker-0d927e3c.js';
-import { m as machineWorker } from './machine-worker-5740c3e5.js';
+import { m as machineWorker } from './machine-worker-63056a0b.js';
 import './worker-def77c26.js';
 import 'stream';
 import 'events';

package/dist/commonjs/{machine-worker-095c9ecb.js → machine-worker-13e601fc.js}

@@ -147,29 +147,36 @@ const _init = async ({ contracts, blocks, peerid })=> {
     return contract
   }));
 
-  const _worker = await new EasyWorker__default["default"](path.join(__dirname, './block-worker.js'), {serialization: 'advanced', type: 'module' });
-  blocks = await _worker.once(blocks);
-  
-  for (const block of blocks) {
-    await Promise.all(block.decoded.transactions.map(async message => {
-      const {from, to, method, params} = message;
-      globalThis.msg = createMessage(from);
+  let lastBlock = {hash: '0x0'}; 
+
+  if (blocks?.length > 0) {
+    const _worker = await new EasyWorker__default["default"](path.join(__dirname, './block-worker.js'), {serialization: 'advanced', type: 'module' });
+    blocks = await _worker.once(blocks);
+    
+    for (const block of blocks) {
+      await Promise.all(block.decoded.transactions.map(async message => {
+        const {from, to, method, params} = message;
+        globalThis.msg = createMessage(from);
+      
+        await execute(to, method, params);
+      }));
+    }
     
-      await execute(to, method, params);
-    }));
+    if (blocks.length > 0) {
+      lastBlock = blocks[blocks.length - 1].decoded;    
+      lastBlock = await new utils.BlockMessage(lastBlock);
+  
+      lastBlock = {
+        ...lastBlock.decoded,
+        hash: await lastBlock.hash
+      };
+    }
   }
 
-  let lastBlock;
-  if (blocks.length > 0) {
-    lastBlock = blocks[blocks.length - 1].decoded;    
-    lastBlock = await new utils.BlockMessage(lastBlock);
+  
 
-    lastBlock = {
-      ...lastBlock.decoded,
-      hash: await lastBlock.hash
-    };
-  }
-  worker.postMessage({type: 'machine-ready', lastBlock });
+  
+  worker.postMessage({type: 'machine-ready', lastBlock});
   _worker.terminate(); 
   
   worker.postMessage(blocks);
@@ -177,14 +184,33 @@ const _init = async ({ contracts, blocks, peerid })=> {
 
 const tasks = async (e) => {
   const id = e.id;
-    if (e.type === 'init') await _init(e.input);
+    if (e.type === 'init') {
+      try {
+        await _init(e.input);
+      } catch (e) {
+        worker.postMessage({
+          type: 'initError',
+          message: e.message,
+          id          
+        });
+      }
+    }
     if (e.type === 'get') {
-      const value = await get(e.input.contract, e.input.method, e.input.params);
-      worker.postMessage({
-        type: 'response',
-        id,
-        value
-      });
+      try {
+        const value = await get(e.input.contract, e.input.method, e.input.params);
+        worker.postMessage({
+          type: 'response',
+          id,
+          value
+        });
+      } catch (e) {
+        worker.postMessage({
+          type: 'fetchError',
+          message: e.message,
+          id          
+        });
+      }
+      
     }
     if (e.type === 'execute') {
       try {

package/dist/commonjs/machine-worker.js

@@ -1,6 +1,6 @@
 'use strict';
 
-require('./machine-worker-095c9ecb.js');
+require('./machine-worker-13e601fc.js');
 require('@leofcoin/codec-format-interface');
 require('./utils-1dc37f72.js');
 require('path');

package/dist/commonjs/workers.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var transactionWorker = require('./transaction-worker-8eecc7a1.js');
 var blockWorker = require('./block-worker-60e4cfa3.js');
 var poolWorker = require('./pool-worker-81e8b4c0.js');
-var machineWorker = require('./machine-worker-095c9ecb.js');
+var machineWorker = require('./machine-worker-13e601fc.js');
 require('@leofcoin/codec-format-interface');
 require('./transaction-220a3a15.js');
 require('@vandeurenglenn/easy-worker');

package/dist/module/{machine-worker-9cbdae03.js → machine-worker-3b7771c0.js}

@@ -141,29 +141,36 @@ const _init = async ({ contracts, blocks, peerid })=> {
     return contract
   }));
 
-  const _worker = await new EasyWorker(join(__dirname, './block-worker.js'), {serialization: 'advanced', type: 'module' });
-  blocks = await _worker.once(blocks);
-  
-  for (const block of blocks) {
-    await Promise.all(block.decoded.transactions.map(async message => {
-      const {from, to, method, params} = message;
-      globalThis.msg = createMessage(from);
+  let lastBlock = {hash: '0x0'}; 
+
+  if (blocks?.length > 0) {
+    const _worker = await new EasyWorker(join(__dirname, './block-worker.js'), {serialization: 'advanced', type: 'module' });
+    blocks = await _worker.once(blocks);
+    
+    for (const block of blocks) {
+      await Promise.all(block.decoded.transactions.map(async message => {
+        const {from, to, method, params} = message;
+        globalThis.msg = createMessage(from);
+      
+        await execute(to, method, params);
+      }));
+    }
     
-      await execute(to, method, params);
-    }));
+    if (blocks.length > 0) {
+      lastBlock = blocks[blocks.length - 1].decoded;    
+      lastBlock = await new BlockMessage(lastBlock);
+  
+      lastBlock = {
+        ...lastBlock.decoded,
+        hash: await lastBlock.hash
+      };
+    }
   }
 
-  let lastBlock;
-  if (blocks.length > 0) {
-    lastBlock = blocks[blocks.length - 1].decoded;    
-    lastBlock = await new BlockMessage(lastBlock);
+  
 
-    lastBlock = {
-      ...lastBlock.decoded,
-      hash: await lastBlock.hash
-    };
-  }
-  worker.postMessage({type: 'machine-ready', lastBlock });
+  
+  worker.postMessage({type: 'machine-ready', lastBlock});
   _worker.terminate(); 
   
   worker.postMessage(blocks);
@@ -171,14 +178,33 @@ const _init = async ({ contracts, blocks, peerid })=> {
 
 const tasks = async (e) => {
   const id = e.id;
-    if (e.type === 'init') await _init(e.input);
+    if (e.type === 'init') {
+      try {
+        await _init(e.input);
+      } catch (e) {
+        worker.postMessage({
+          type: 'initError',
+          message: e.message,
+          id          
+        });
+      }
+    }
     if (e.type === 'get') {
-      const value = await get(e.input.contract, e.input.method, e.input.params);
-      worker.postMessage({
-        type: 'response',
-        id,
-        value
-      });
+      try {
+        const value = await get(e.input.contract, e.input.method, e.input.params);
+        worker.postMessage({
+          type: 'response',
+          id,
+          value
+        });
+      } catch (e) {
+        worker.postMessage({
+          type: 'fetchError',
+          message: e.message,
+          id          
+        });
+      }
+      
     }
     if (e.type === 'execute') {
       try {

package/dist/module/machine-worker.js

@@ -1,4 +1,4 @@
-import './machine-worker-9cbdae03.js';
+import './machine-worker-3b7771c0.js';
 import '@leofcoin/codec-format-interface';
 import './utils-e87bc63d.js';
 import 'path';

package/dist/module/workers.js

@@ -1,7 +1,7 @@
 import { t as transactionWorker } from './transaction-worker-105deaa8.js';
 import { b as blockWorker } from './block-worker-f539b1b2.js';
 import { p as poolWorker } from './pool-worker-f65671d7.js';
-import { m as machineWorker } from './machine-worker-9cbdae03.js';
+import { m as machineWorker } from './machine-worker-3b7771c0.js';
 import '@leofcoin/codec-format-interface';
 import './transaction-d06dc6c4.js';
 import '@vandeurenglenn/easy-worker';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/workers",
-  "version": "1.2.4",
+  "version": "1.2.5",
   "description": "",
   "module": "src/workers.js",
   "scripts": {

package/src/machine-worker.js

@@ -109,29 +109,36 @@ const _init = async ({ contracts, blocks, peerid })=> {
     return contract
   }))
 
-  const _worker = await new EasyWorker(join(__dirname, './block-worker.js'), {serialization: 'advanced', type: 'module' })
-  blocks = await _worker.once(blocks)
-  
-  for (const block of blocks) {
-    await Promise.all(block.decoded.transactions.map(async message => {
-      const {from, to, method, params} = message;
-      globalThis.msg = createMessage(from);
+  let lastBlock = {hash: '0x0'}; 
+
+  if (blocks?.length > 0) {
+    const _worker = await new EasyWorker(join(__dirname, './block-worker.js'), {serialization: 'advanced', type: 'module' })
+    blocks = await _worker.once(blocks)
+    
+    for (const block of blocks) {
+      await Promise.all(block.decoded.transactions.map(async message => {
+        const {from, to, method, params} = message;
+        globalThis.msg = createMessage(from);
+      
+        await execute(to, method, params);
+      }));
+    }
     
-      await execute(to, method, params);
-    }));
+    if (blocks.length > 0) {
+      lastBlock = blocks[blocks.length - 1].decoded;    
+      lastBlock = await new BlockMessage(lastBlock);
+  
+      lastBlock = {
+        ...lastBlock.decoded,
+        hash: await lastBlock.hash
+      };
+    }
   }
 
-  let lastBlock;
-  if (blocks.length > 0) {
-    lastBlock = blocks[blocks.length - 1].decoded;    
-    lastBlock = await new BlockMessage(lastBlock);
+  
 
-    lastBlock = {
-      ...lastBlock.decoded,
-      hash: await lastBlock.hash
-    };
-  }
-  worker.postMessage({type: 'machine-ready', lastBlock });
+  
+  worker.postMessage({type: 'machine-ready', lastBlock});
   _worker.terminate(); 
   
   worker.postMessage(blocks);
@@ -139,14 +146,33 @@ const _init = async ({ contracts, blocks, peerid })=> {
 
 const tasks = async (e) => {
   const id = e.id
-    if (e.type === 'init') await _init(e.input)
+    if (e.type === 'init') {
+      try {
+        await _init(e.input)
+      } catch (e) {
+        worker.postMessage({
+          type: 'initError',
+          message: e.message,
+          id          
+        })
+      }
+    }
     if (e.type === 'get') {
-      const value = await get(e.input.contract, e.input.method, e.input.params)
-      worker.postMessage({
-        type: 'response',
-        id,
-        value
-      })
+      try {
+        const value = await get(e.input.contract, e.input.method, e.input.params)
+        worker.postMessage({
+          type: 'response',
+          id,
+          value
+        })
+      } catch (e) {
+        worker.postMessage({
+          type: 'fetchError',
+          message: e.message,
+          id          
+        })
+      }
+      
     }
     if (e.type === 'execute') {
       try {