@leofcoin/workers 1.1.1 → 1.2.1

package/dist/module/block-worker-f539b1b2.js

@@ -0,0 +1,44 @@
+import '@leofcoin/codec-format-interface';
+import { B as BigNumber, a as BlockMessage, f as formatBytes } from './utils-e87bc63d.js';
+import EasyWorker from '@vandeurenglenn/easy-worker';
+
+const worker = new EasyWorker();
+
+globalThis.BigNumber = BigNumber;
+
+globalThis.peernet = globalThis.peernet || {};
+globalThis.contracts = {};
+
+const run = async (blocks) => {  
+  blocks = await Promise.all(blocks.map(block => new BlockMessage(block)));
+  blocks = blocks.sort((a, b) => a.decoded.timestamp - b.decoded.timestamp);
+
+  blocks = await Promise.all(blocks.map(block => new Promise(async (resolve, reject) => {
+    // todo: tx worker or nah?
+    const size = block.encoded.length || block.encoded.byteLength;
+    console.log(`loaded block: ${await block.hash} @${block.decoded.index} ${formatBytes(size)}`);
+    resolve(block);
+  })));
+  return blocks
+};
+
+const tasks = async blocks => {
+  globalThis.peernet.codecs =  {
+    'block-message': {
+      codec: parseInt('626d', 16),
+      hashAlg: 'keccak-256'
+    }
+  };  
+  
+  blocks = await run(blocks);
+  worker.postMessage(blocks);
+};
+ 
+
+worker.onmessage(data => tasks(data));
+
+var blockWorker = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+export { blockWorker as b };

package/dist/module/block-worker.js

@@ -1,8 +1,7 @@
 import '@leofcoin/codec-format-interface';
-import './block-worker-d07e9a9f.js';
-import './utils-96ad7b3e.js';
-import 'child_process';
-import 'path';
+import './utils-e87bc63d.js';
+import '@vandeurenglenn/easy-worker';
+import './block-worker-f539b1b2.js';
 import 'bn.js';
 import '@ethersproject/bytes';
 import '@ethersproject/logger';

package/dist/module/{machine-worker-12c3eda2.js → machine-worker-a2897101.js}

@@ -1,7 +1,7 @@
 import { FormatInterface } from '@leofcoin/codec-format-interface';
-import { B as BigNumber, f as formatBytes } from './utils-96ad7b3e.js';
-import { fork } from 'child_process';
+import { B as BigNumber, a as BlockMessage, f as formatBytes } from './utils-e87bc63d.js';
 import { join } from 'path';
+import EasyWorker from '@vandeurenglenn/easy-worker';
 
 var proto = `
 message ContractMessage {
@@ -36,6 +36,8 @@ var bytecodes = {
 	validators: validators
 };
 
+const worker = new EasyWorker();
+
 const contractFactoryMessage = bytecodes.contractFactory;
 const nativeTokenMessage = bytecodes.nativeToken;
 const nameServiceMessage = bytecodes.nameService;
@@ -92,7 +94,6 @@ const execute = async (contract, method, params) => {
     } else {
       result = await contracts[contract][method](...params);
     }
-
     // state.put(result)
     return result
   } catch (e) {
@@ -140,24 +141,34 @@ const _init = async ({ contracts, blocks, peerid })=> {
     return contract
   }));
 
-  const worker = fork(join(__dirname, './block-worker.js'), {serialization: 'advanced'});
+  const _worker = await new EasyWorker(join(__dirname, './block-worker.js'), {serialization: 'advanced', type: 'module' });
   // worker.on('message')
-    worker.once('message', async (blocks) => {
+    _worker.once('message', async (blocks) => {
       for (const block of blocks) {
         await Promise.all(block.decoded.transactions.map(async message => {
-          const {from, to, method, params} = message.decoded;
+          const {from, to, method, params} = message;
           globalThis.msg = createMessage(from);
         
           await execute(to, method, params);
         }));
       }
-      process.send({type: 'machine-ready'});
-      worker.kill(); 
+      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.terminate(); 
         
 
       
     });
-    worker.send(blocks);
+    worker.postMessage(blocks);
 };
 
 const tasks = async (e) => {
@@ -165,7 +176,7 @@ const tasks = async (e) => {
     if (e.type === 'init') await _init(e.input);
     if (e.type === 'get') {
       const value = await get(e.input.contract, e.input.method, e.input.params);
-      process.send({
+      worker.postMessage({
         type: 'response',
         id,
         value
@@ -174,13 +185,13 @@ const tasks = async (e) => {
     if (e.type === 'execute') {
       try {
         const value = await execute(e.input.contract, e.input.method, e.input.params);
-        process.send({
+        worker.postMessage({
           type: 'response',
           id,
           value
         });
       } catch(e) {
-        process.send({
+        worker.postMessage({
           type: 'executionError',
           message: e.message,
           id
@@ -190,12 +201,7 @@ const tasks = async (e) => {
     }
   };
 
-
-if (globalThis.process) {
-  process.on('message', tasks);
-} else {
-  onmessage = message => tasks(message.data);
-}
+worker.onmessage(data => tasks(data));
 
 var machineWorker = /*#__PURE__*/Object.freeze({
   __proto__: null

package/dist/module/machine-worker.js

@@ -1,8 +1,8 @@
-import './machine-worker-12c3eda2.js';
+import './machine-worker-a2897101.js';
 import '@leofcoin/codec-format-interface';
-import './utils-96ad7b3e.js';
-import 'child_process';
+import './utils-e87bc63d.js';
 import 'path';
+import '@vandeurenglenn/easy-worker';
 import 'bn.js';
 import '@ethersproject/bytes';
 import '@ethersproject/logger';

package/dist/module/{pool-worker-8d3369b4.js → pool-worker-f65671d7.js}

@@ -1,23 +1,18 @@
 import '@leofcoin/codec-format-interface';
 import { T as TransactionMessage } from './transaction-d06dc6c4.js';
+import EasyWorker from '@vandeurenglenn/easy-worker';
 
 globalThis.peernet = globalThis.peernet || {};
 globalThis.contracts = {};
 
+const worker = new EasyWorker();
+
 const tasks = async transactions => {
   
   globalThis.peernet.codecs =  {
-    'contract-message': {
-      codec: parseInt('63636d', 16),
-      hashAlg: 'keccak-256'
-    },
     'transaction-message': {
       codec: parseInt('746d', 16),
       hashAlg: 'keccak-256'
-    },
-    'block-message': {
-      codec: parseInt('626d', 16),
-      hashAlg: 'keccak-256'
     }
   };
   
@@ -27,15 +22,10 @@ const tasks = async transactions => {
     return {...message.decoded, hash: await message.hash, size: message.encoded.length}
   }));
 
-  globalThis.process ? process.send(transactions) : postMessage(transactions);
+  worker.postMessage(transactions);
   
 };
-
-if (globalThis.process) {
-  process.on('message', tasks);
-} else {
-  onmessage = message => tasks(message.data);
-}
+ worker.onmessage(data => tasks(data));
 
 var poolWorker = /*#__PURE__*/Object.freeze({
   __proto__: null

package/dist/module/pool-worker.js

@@ -1,3 +1,4 @@
 import '@leofcoin/codec-format-interface';
 import './transaction-d06dc6c4.js';
-import './pool-worker-8d3369b4.js';
+import '@vandeurenglenn/easy-worker';
+import './pool-worker-f65671d7.js';

package/dist/module/{transaction-worker-0f96397e.js → transaction-worker-105deaa8.js}

@@ -1,29 +1,22 @@
 import '@leofcoin/codec-format-interface';
 import { T as TransactionMessage } from './transaction-d06dc6c4.js';
+import EasyWorker from '@vandeurenglenn/easy-worker';
 
 globalThis.peernet = globalThis.peernet || {};
 globalThis.contracts = {};
- 
 
-process.on('message', async (transactions) => {
-  
-globalThis.peernet.codecs =  {
-  'contract-message': {
-    codec: parseInt('63636d', 16),
-    hashAlg: 'keccak-256'
-  },
-  'transaction-message': {
-    codec: parseInt('746d', 16),
-    hashAlg: 'keccak-256'
-  },
-  'block-message': {
-    codec: parseInt('626d', 16),
-    hashAlg: 'keccak-256'
-  }
-};
+const worker = new EasyWorker();
+
+worker.onmessage(async (transactions) => {  
+  globalThis.peernet.codecs =  {
+    'transaction-message': {
+      codec: parseInt('746d', 16),
+      hashAlg: 'keccak-256'
+    }
+  };
   transactions = await Promise.all(transactions.map(async message => new TransactionMessage(message)));
 
-  process.send(transactions);
+  worker.postMessage(transactions);
 });
 
 var transactionWorker = /*#__PURE__*/Object.freeze({

package/dist/module/transaction-worker.js

@@ -1,3 +1,4 @@
 import '@leofcoin/codec-format-interface';
 import './transaction-d06dc6c4.js';
-import './transaction-worker-0f96397e.js';
+import '@vandeurenglenn/easy-worker';
+import './transaction-worker-105deaa8.js';

package/dist/module/{utils-96ad7b3e.js → utils-e87bc63d.js}

@@ -1,8 +1,51 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
 import _BN from 'bn.js';
 import { isBytes, hexlify, isHexString } from '@ethersproject/bytes';
 import { Logger } from '@ethersproject/logger';
 import '@ethersproject/bignumber';
 
+var proto = `
+message ValidatorMessage {
+  required string address = 1;
+  required string reward = 2;
+}
+
+message Transaction {
+  required string hash = 1;
+  required uint64 timestamp = 2;
+  required string from = 3;
+  required string to = 4;
+  required uint64 nonce = 5;
+  required string method = 6;
+  repeated string params = 7;
+}
+
+message BlockMessage {
+  required uint64 index = 1;
+  required string previousHash = 3;
+  required uint64 timestamp = 4;
+  required uint64 reward = 5;
+  required string fees = 6;
+  repeated Transaction transactions = 7;
+  repeated ValidatorMessage validators = 8;
+}
+`;
+
+class BlockMessage extends FormatInterface {
+  get keys() {
+    return ['index', 'previousHash', 'timestamp', 'reward', 'fees', 'transactions', 'validators']
+  }
+
+  get messageName() {
+    return 'BlockMessage'
+  }
+
+  constructor(buffer) {
+    const name = 'block-message';
+    super(buffer, proto, {name});
+  }
+}
+
 const version$1 = "bignumber/5.6.2";
 
 var BN = _BN.BN;
@@ -298,4 +341,4 @@ const formatBytes = (bytes, decimals = 2) => {
   return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${byteFormats[i]}`
 };
 
-export { BigNumber as B, formatBytes as f };
+export { BigNumber as B, BlockMessage as a, formatBytes as f };

package/dist/module/workers.js

@@ -1,15 +1,15 @@
-import { t as transactionWorker } from './transaction-worker-0f96397e.js';
-import { b as blockWorker } from './block-worker-d07e9a9f.js';
-import { p as poolWorker } from './pool-worker-8d3369b4.js';
-import { m as machineWorker } from './machine-worker-12c3eda2.js';
+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-a2897101.js';
 import '@leofcoin/codec-format-interface';
 import './transaction-d06dc6c4.js';
-import './utils-96ad7b3e.js';
+import '@vandeurenglenn/easy-worker';
+import './utils-e87bc63d.js';
 import 'bn.js';
 import '@ethersproject/bytes';
 import '@ethersproject/logger';
 import '@ethersproject/bignumber';
-import 'child_process';
 import 'path';
 
 const TransactionWorker = transactionWorker;

package/package.json

@@ -1,22 +1,22 @@
-{
-  "name": "@leofcoin/workers",
-  "version": "1.1.1",
-  "description": "",
-  "module": "src/workers.js",
-  "scripts": {
-    "build": "rollup -c",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "MIT",
-  "devDependencies": {
-    "@rollup/plugin-commonjs": "^22.0.2",
-    "@rollup/plugin-json": "^4.1.0",
-    "@rollup/plugin-node-resolve": "^14.1.0",
-    "rollup": "^2.79.1"
-  },
-  "dependencies": {
-    "@leofcoin/messages": "^1.2.0"
-  }
-}
+{
+  "name": "@leofcoin/workers",
+  "version": "1.2.1",
+  "description": "",
+  "module": "src/workers.js",
+  "scripts": {
+    "build": "rollup -c",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^22.0.2",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^14.1.0",
+    "rollup": "^2.79.1"
+  },
+  "dependencies": {
+    "@leofcoin/messages": "^1.2.0"
+  }
+}

package/src/block-worker.js

@@ -1,13 +1,9 @@
-import { BlockMessage, ContractMessage, TransactionMessage } from '../../messages/src/messages'
-import { formatBytes, BigNumber } from '../../utils/src/utils'
-import bytecodes  from '../../lib/src/bytecodes.json'
-import { fork } from 'child_process'
-import { join } from 'path'
+import { BlockMessage } from './../../messages/src/messages'
+import { formatBytes, BigNumber } from './../../utils/src/utils'
 
-const contractFactoryMessage = bytecodes.contractFactory
-const nativeTokenMessage = bytecodes.nativeToken
-const nameServiceMessage = bytecodes.nameService
-const validatorsMessage = bytecodes.validators
+import EasyWorker from '@vandeurenglenn/easy-worker'
+
+const worker = new EasyWorker()
 
 globalThis.BigNumber = BigNumber
 
@@ -19,42 +15,16 @@ const run = async (blocks) => {
   blocks = blocks.sort((a, b) => a.decoded.timestamp - b.decoded.timestamp)
 
   blocks = await Promise.all(blocks.map(block => new Promise(async (resolve, reject) => {
-    if (globalThis.process) {
-      const worker = fork(join(__dirname, './transaction-worker.js'), {serialization: 'advanced'})
-    
-      worker.once('message', async transactions => {
-        block.decoded.transactions = transactions
-        const size = block.encoded.length || block.encoded.byteLength
-        console.log(`loaded block: ${await block.hash} @${block.decoded.index} ${formatBytes(size)}`);
-        resolve(block)
-      })
-      
-      worker.send(block.decoded.transactions)
-    } else {
-      const worker = new Worker('./workers/transaction-worker.js')
-      worker.onmessage = async message => {
-        const transactions = message.data
-        block.decoded.transactions = transactions
-        const size = block.encoded.length || block.encoded.byteLength
-        console.log(`loaded block: ${await block.hash} @${block.decoded.index} ${formatBytes(size)}`);
-        resolve(block)
-      }
-      worker.postMessage(block.decoded.transactions)
-    }    
+    // todo: tx worker or nah?
+    const size = block.encoded.length || block.encoded.byteLength
+    console.log(`loaded block: ${await block.hash} @${block.decoded.index} ${formatBytes(size)}`);
+    resolve(block)
   })))
   return blocks
 }
 
 const tasks = async blocks => {
   globalThis.peernet.codecs =  {
-    'contract-message': {
-      codec: parseInt('63636d', 16),
-      hashAlg: 'keccak-256'
-    },
-    'transaction-message': {
-      codec: parseInt('746d', 16),
-      hashAlg: 'keccak-256'
-    },
     'block-message': {
       codec: parseInt('626d', 16),
       hashAlg: 'keccak-256'
@@ -62,11 +32,9 @@ const tasks = async blocks => {
   }  
   
   blocks = await run(blocks)
-  globalThis.process ? process.send(blocks) : postMessage(blocks)
+  worker.postMessage(blocks)
 }
  
-if (globalThis.process) {
-  process.on('message', tasks)
-} else {
-  onmessage = message => tasks(message.data)
-}
+
+worker.onmessage(data => tasks(data))
+

package/src/machine-worker.js

@@ -1,8 +1,11 @@
-import { BlockMessage, ContractMessage, TransactionMessage } from './../../messages/src/messages'
+import { BlockMessage, ContractMessage } from './../../messages/src/messages'
 import { formatBytes, BigNumber } from './../../utils/src/utils'
 import bytecodes  from './../../lib/src/bytecodes.json'
-import { fork } from 'child_process'
 import { join } from 'path'
+
+import EasyWorker from '@vandeurenglenn/easy-worker'
+const worker = new EasyWorker()
+
 const contractFactoryMessage = bytecodes.contractFactory
 const nativeTokenMessage = bytecodes.nativeToken
 const nameServiceMessage = bytecodes.nameService
@@ -59,7 +62,6 @@ const execute = async (contract, method, params) => {
     } else {
       result = await contracts[contract][method](...params)
     }
-
     // state.put(result)
     return result
   } catch (e) {
@@ -107,24 +109,34 @@ const _init = async ({ contracts, blocks, peerid })=> {
     return contract
   }))
 
-  const worker = fork(join(__dirname, './block-worker.js'), {serialization: 'advanced'})
+  const _worker = await new EasyWorker(join(__dirname, './block-worker.js'), {serialization: 'advanced', type: 'module' })
   // worker.on('message')
-    worker.once('message', async (blocks) => {
+    _worker.once('message', async (blocks) => {
       for (const block of blocks) {
         await Promise.all(block.decoded.transactions.map(async message => {
-          const {from, to, method, params} = message.decoded
+          const {from, to, method, params} = message
           globalThis.msg = createMessage(from)
         
           await execute(to, method, params)
         }))
       }
-      process.send({type: 'machine-ready'})
-      worker.kill() 
+      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.terminate() 
         
 
       
     })
-    worker.send(blocks)
+    worker.postMessage(blocks)
 }
 
 const tasks = async (e) => {
@@ -132,7 +144,7 @@ const tasks = async (e) => {
     if (e.type === 'init') await _init(e.input)
     if (e.type === 'get') {
       const value = await get(e.input.contract, e.input.method, e.input.params)
-      process.send({
+      worker.postMessage({
         type: 'response',
         id,
         value
@@ -141,13 +153,13 @@ const tasks = async (e) => {
     if (e.type === 'execute') {
       try {
         const value = await execute(e.input.contract, e.input.method, e.input.params)
-        process.send({
+        worker.postMessage({
           type: 'response',
           id,
           value
         })
       } catch(e) {
-        process.send({
+        worker.postMessage({
           type: 'executionError',
           message: e.message,
           id
@@ -157,9 +169,4 @@ const tasks = async (e) => {
     }
   }
 
-
-if (globalThis.process) {
-  process.on('message', tasks)
-} else {
-  onmessage = message => tasks(message.data)
-}
+worker.onmessage(data => tasks(data))

package/src/pool-worker.js

@@ -1,22 +1,18 @@
-import { TransactionMessage } from '../../messages/src/messages'
+import { TransactionMessage } from './../../messages/src/messages'
+
+import EasyWorker from '@vandeurenglenn/easy-worker'
 
 globalThis.peernet = globalThis.peernet || {}
 globalThis.contracts = {}
 
+const worker = new EasyWorker()
+
 const tasks = async transactions => {
   
   globalThis.peernet.codecs =  {
-    'contract-message': {
-      codec: parseInt('63636d', 16),
-      hashAlg: 'keccak-256'
-    },
     'transaction-message': {
       codec: parseInt('746d', 16),
       hashAlg: 'keccak-256'
-    },
-    'block-message': {
-      codec: parseInt('626d', 16),
-      hashAlg: 'keccak-256'
     }
   }
   
@@ -26,12 +22,7 @@ const tasks = async transactions => {
     return {...message.decoded, hash: await message.hash, size: message.encoded.length}
   }))
 
-  globalThis.process ? process.send(transactions) : postMessage(transactions)
+  worker.postMessage(transactions)
   
 }
-
-if (globalThis.process) {
-  process.on('message', tasks)
-} else {
-  onmessage = message => tasks(message.data)
-}
+ worker.onmessage(data => tasks(data))

package/src/transaction-worker.js

@@ -1,26 +1,20 @@
-import { TransactionMessage } from '../../messages/src/messages'
+import { TransactionMessage } from './../../messages/src/messages.js'
 
 globalThis.peernet = globalThis.peernet || {}
 globalThis.contracts = {}
- 
 
-process.on('message', async (transactions) => {
-  
-globalThis.peernet.codecs =  {
-  'contract-message': {
-    codec: parseInt('63636d', 16),
-    hashAlg: 'keccak-256'
-  },
-  'transaction-message': {
-    codec: parseInt('746d', 16),
-    hashAlg: 'keccak-256'
-  },
-  'block-message': {
-    codec: parseInt('626d', 16),
-    hashAlg: 'keccak-256'
+import EasyWorker from '@vandeurenglenn/easy-worker'
+
+const worker = new EasyWorker()
+
+worker.onmessage(async (transactions) => {  
+  globalThis.peernet.codecs =  {
+    'transaction-message': {
+      codec: parseInt('746d', 16),
+      hashAlg: 'keccak-256'
+    }
   }
-}
   transactions = await Promise.all(transactions.map(async message => new TransactionMessage(message)))
 
-  process.send(transactions)
-});
+  worker.postMessage(transactions)
+})