@leofcoin/workers 1.1.0 → 1.2.0

package/dist/bundle/module/{machine-worker-a812956d.js → machine-worker-421324a1.js}

@@ -1,6 +1,6 @@
-import { F as FormatInterface_1 } from './index-6715242b.js';
-import { B as BigNumber, f as formatBytes } from './utils-d240ed61.js';
-import { fork } from 'child_process';
+import { F as FormatInterface_1, E as EasyWorker } from './worker-def77c26.js';
+import { B as BigNumber, a as BlockMessage, f as formatBytes } from './utils-ac8c68e6.js';
+import { join } from 'path';
 
 var proto = `
 message ContractMessage {
@@ -35,6 +35,8 @@ var bytecodes = {
 	validators: validators
 };
 
+const worker = new EasyWorker();
+
 const contractFactoryMessage = bytecodes.contractFactory;
 const nativeTokenMessage = bytecodes.nativeToken;
 const nameServiceMessage = bytecodes.nameService;
@@ -45,6 +47,7 @@ globalThis.BigNumber = BigNumber;
 globalThis.peernet = globalThis.peernet || {};
 globalThis.contracts = {};
 
+
 const get = (contract, method, params) => {
   let result;
   if (params?.length > 0) {
@@ -90,7 +93,6 @@ const execute = async (contract, method, params) => {
     } else {
       result = await contracts[contract][method](...params);
     }
-
     // state.put(result)
     return result
   } catch (e) {
@@ -108,6 +110,22 @@ const createMessage = (sender = globalThis.peerid) => {
 };
 
 const _init = async ({ contracts, blocks, peerid })=> {
+  
+  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'
+    }
+  };
+
   globalThis.peerid = peerid;
   contracts = [
     contractFactoryMessage,
@@ -122,19 +140,29 @@ const _init = async ({ contracts, blocks, peerid })=> {
     return contract
   }));
 
-  const worker = fork('./workers/block-worker.js', {serialization: 'advanced'});
+  const _worker = new EasyWorker(join(__dirname, './block-worker.js'), {serialization: 'advanced'});
   // 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(); 
         
 
       
@@ -143,54 +171,36 @@ const _init = async ({ contracts, blocks, peerid })=> {
 };
 
 const tasks = async (e) => {
-  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 id = e.id;
     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: e.id,
+        id,
         value
       });
     }
     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: e.id,
+          id,
           value
         });
       } catch(e) {
-        process.send({
+        worker.postMessage({
           type: 'executionError',
-          message: e,
-          id: e.id
+          message: e.message,
+          id
           
         });
       }
     }
   };
 
-
-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/bundle/module/machine-worker.js

@@ -1,12 +1,11 @@
-import './machine-worker-a812956d.js';
-import './index-6715242b.js';
-import './utils-d240ed61.js';
-import 'child_process';
+import './machine-worker-421324a1.js';
+import './worker-def77c26.js';
+import './utils-ac8c68e6.js';
+import 'path';
 import 'stream';
 import 'events';
 import 'buffer';
 import 'util';
 import 'string_decoder/';
 import 'fs';
-import 'path';
 import 'os';

package/dist/bundle/module/{pool-worker-012d12c9.js → pool-worker-0d927e3c.js}

@@ -1,23 +1,17 @@
-import './index-6715242b.js';
-import { T as TransactionMessage } from './transaction-e9126d7b.js';
+import { E as EasyWorker } from './worker-def77c26.js';
+import { T as TransactionMessage } from './transaction-cec98ce8.js';
 
 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 +21,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/bundle/module/pool-worker.js

@@ -1,6 +1,6 @@
-import './index-6715242b.js';
-import './transaction-e9126d7b.js';
-import './pool-worker-012d12c9.js';
+import './worker-def77c26.js';
+import './transaction-cec98ce8.js';
+import './pool-worker-0d927e3c.js';
 import 'stream';
 import 'events';
 import 'buffer';

package/dist/bundle/module/{transaction-e9126d7b.js → transaction-cec98ce8.js}

@@ -1,4 +1,4 @@
-import { F as FormatInterface_1 } from './index-6715242b.js';
+import { F as FormatInterface_1 } from './worker-def77c26.js';
 
 var proto = `
 

package/dist/bundle/module/transaction-worker-548cd200.js

@@ -0,0 +1,25 @@
+import { E as EasyWorker } from './worker-def77c26.js';
+import { T as TransactionMessage } from './transaction-cec98ce8.js';
+
+globalThis.peernet = globalThis.peernet || {};
+globalThis.contracts = {};
+
+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)));
+
+  worker.postMessage(transactions);
+});
+
+var transactionWorker = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+export { transactionWorker as t };

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

@@ -1,6 +1,6 @@
-import './index-6715242b.js';
-import './transaction-e9126d7b.js';
-import './transaction-worker-8afddd7e.js';
+import './worker-def77c26.js';
+import './transaction-cec98ce8.js';
+import './transaction-worker-548cd200.js';
 import 'stream';
 import 'events';
 import 'buffer';

package/dist/bundle/module/{utils-d240ed61.js → utils-ac8c68e6.js}

@@ -1,4 +1,46 @@
-import { c as commonjsGlobal } from './index-6715242b.js';
+import { F as FormatInterface_1, c as commonjsGlobal } from './worker-def77c26.js';
+
+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_1 {
+  get keys() {
+    return ['index', 'previousHash', 'timestamp', 'reward', 'fees', 'transactions', 'validators']
+  }
+
+  get messageName() {
+    return 'BlockMessage'
+  }
+
+  constructor(buffer) {
+    const name = 'block-message';
+    super(buffer, proto, {name});
+  }
+}
 
 var bn = {exports: {}};
 
@@ -4090,4 +4132,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/bundle/module/{index-6715242b.js → worker-def77c26.js}

@@ -4777,4 +4777,82 @@ dist.CodecHash = CodecHash;
 dist.Codecs = Codecs;
 var FormatInterface_1 = dist.FormatInterface = FormatInterface;
 
-export { FormatInterface_1 as F, commonjsGlobal as c };
+class EasyWorker {
+  #messageEvent = 'message'
+  #errorEvent = 'error'
+  #isBrowser = false
+  #isWorker = false
+
+  get isWorker() {
+    return this.#isWorker
+  }
+  constructor(url, options) {
+    return this.#init(url, options)
+  }
+
+  #init(url, options = {}) {
+    if (url) {
+      if (globalThis.Worker) {
+        this.#isBrowser = true;
+        this.worker = new Worker(url, {...options});
+      } else {
+        return new Promise(async (resolve, reject) => {
+          const {fork} = await import('child_process');  
+          this.worker = fork(url, ['easy-worker-child'], options);
+          resolve(this);
+        })
+      }
+    } else {
+      this.#isWorker = true;
+      if (globalThis.process?.argv[2] === 'easy-worker-child') {
+        this.worker = process;
+      } else {
+        this.#isBrowser = true;
+        this.worker = globalThis;
+      }
+    }
+    
+    return this
+  }
+
+  onmessage(fn) {
+    if (this.#isBrowser) this.worker.onmessage = ({data}) => fn(data);
+    else this.worker.on(this.#messageEvent, fn);
+  }
+
+  postMessage(message) {
+    if (this.#isBrowser) this.worker.postMessage(message);
+    else this.worker.send(message);
+  }
+
+  terminate() {
+    if (this.#isBrowser) this.worker.terminate();
+    else this.worker.kill();
+  }
+
+  onerror(fn) {
+    if (this.#isBrowser) this.worker.onerror = fn;
+    else this.worker.on(this.#errorEvent, fn);
+  }
+
+  /**
+   * 
+   * @param {*} data 
+   * @returns {Promise} resolves result onmessage & rejects on error
+   */
+  once(data) {
+    return new Promise((resolve, reject) => {
+      this.onmessage(message => {
+        resolve(message);
+        this.terminate();
+      });
+      this.onerror(error => {
+        reject(error);
+        this.terminate();
+      });
+      this.postMessage(data);
+    })    
+  }  
+}
+
+export { EasyWorker as E, FormatInterface_1 as F, commonjsGlobal as c };

package/dist/bundle/module/workers.js

@@ -1,8 +1,8 @@
-import { t as transactionWorker } from './transaction-worker-8afddd7e.js';
-import { b as blockWorker } from './block-worker-efe837c4.js';
-import { p as poolWorker } from './pool-worker-012d12c9.js';
-import { m as machineWorker } from './machine-worker-a812956d.js';
-import './index-6715242b.js';
+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-421324a1.js';
+import './worker-def77c26.js';
 import 'stream';
 import 'events';
 import 'buffer';
@@ -11,9 +11,8 @@ import 'string_decoder/';
 import 'fs';
 import 'path';
 import 'os';
-import './transaction-e9126d7b.js';
-import './utils-d240ed61.js';
-import 'child_process';
+import './transaction-cec98ce8.js';
+import './utils-ac8c68e6.js';
 
 const TransactionWorker = transactionWorker;
 const BlockWorker = blockWorker;

package/dist/commonjs/block-worker-60e4cfa3.js

@@ -0,0 +1,50 @@
+'use strict';
+
+require('@leofcoin/codec-format-interface');
+var utils = require('./utils-1dc37f72.js');
+var EasyWorker = require('@vandeurenglenn/easy-worker');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EasyWorker__default = /*#__PURE__*/_interopDefaultLegacy(EasyWorker);
+
+const worker = new EasyWorker__default["default"]();
+
+globalThis.BigNumber = utils.BigNumber;
+
+globalThis.peernet = globalThis.peernet || {};
+globalThis.contracts = {};
+
+const run = async (blocks) => {  
+  blocks = await Promise.all(blocks.map(block => new utils.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} ${utils.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
+});
+
+exports.blockWorker = blockWorker;

package/dist/commonjs/block-worker.js

@@ -1,9 +1,9 @@
 'use strict';
 
 require('@leofcoin/codec-format-interface');
-require('./block-worker-d849f917.js');
-require('./utils-def2fce8.js');
-require('child_process');
+require('./utils-1dc37f72.js');
+require('@vandeurenglenn/easy-worker');
+require('./block-worker-60e4cfa3.js');
 require('bn.js');
 require('@ethersproject/bytes');
 require('@ethersproject/logger');

package/dist/{bundle/commonjs/machine-worker-b376daef.js → commonjs/machine-worker-696e3b91.js}

@@ -1,8 +1,13 @@
 'use strict';
 
-var index = require('./index-f77ba3de.js');
-var utils = require('./utils-6a02b156.js');
-var child_process = require('child_process');
+var codecFormatInterface = require('@leofcoin/codec-format-interface');
+var utils = require('./utils-1dc37f72.js');
+var path = require('path');
+var EasyWorker = require('@vandeurenglenn/easy-worker');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EasyWorker__default = /*#__PURE__*/_interopDefaultLegacy(EasyWorker);
 
 var proto = `
 message ContractMessage {
@@ -12,7 +17,7 @@ message ContractMessage {
 }
 `;
 
-class ContractMessage extends index.FormatInterface_1 {
+class ContractMessage extends codecFormatInterface.FormatInterface {
   get keys() {
     return ['creator', 'contract', 'constructorParameters']
   }
@@ -37,6 +42,8 @@ var bytecodes = {
 	validators: validators
 };
 
+const worker = new EasyWorker__default["default"]();
+
 const contractFactoryMessage = bytecodes.contractFactory;
 const nativeTokenMessage = bytecodes.nativeToken;
 const nameServiceMessage = bytecodes.nameService;
@@ -47,6 +54,7 @@ globalThis.BigNumber = utils.BigNumber;
 globalThis.peernet = globalThis.peernet || {};
 globalThis.contracts = {};
 
+
 const get = (contract, method, params) => {
   let result;
   if (params?.length > 0) {
@@ -92,7 +100,6 @@ const execute = async (contract, method, params) => {
     } else {
       result = await contracts[contract][method](...params);
     }
-
     // state.put(result)
     return result
   } catch (e) {
@@ -110,6 +117,22 @@ const createMessage = (sender = globalThis.peerid) => {
 };
 
 const _init = async ({ contracts, blocks, peerid })=> {
+  
+  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'
+    }
+  };
+
   globalThis.peerid = peerid;
   contracts = [
     contractFactoryMessage,
@@ -124,19 +147,29 @@ const _init = async ({ contracts, blocks, peerid })=> {
     return contract
   }));
 
-  const worker = child_process.fork('./workers/block-worker.js', {serialization: 'advanced'});
+  const _worker = new EasyWorker__default["default"](path.join(__dirname, './block-worker.js'), {serialization: 'advanced'});
   // 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 utils.BlockMessage(lastBlock);
+        lastBlock = {
+          ...lastBlock.decoded,
+          hash: await lastBlock.hash
+        };
+      }
+      worker.postMessage({type: 'machine-ready', lastBlock });
+      _worker.terminate(); 
         
 
       
@@ -145,54 +178,36 @@ const _init = async ({ contracts, blocks, peerid })=> {
 };
 
 const tasks = async (e) => {
-  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 id = e.id;
     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: e.id,
+        id,
         value
       });
     }
     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: e.id,
+          id,
           value
         });
       } catch(e) {
-        process.send({
+        worker.postMessage({
           type: 'executionError',
-          message: e,
-          id: e.id
+          message: e.message,
+          id
           
         });
       }
     }
   };
 
-
-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/commonjs/machine-worker.js

@@ -1,9 +1,10 @@
 'use strict';
 
-require('./machine-worker-481c0a4b.js');
+require('./machine-worker-696e3b91.js');
 require('@leofcoin/codec-format-interface');
-require('./utils-def2fce8.js');
-require('child_process');
+require('./utils-1dc37f72.js');
+require('path');
+require('@vandeurenglenn/easy-worker');
 require('bn.js');
 require('@ethersproject/bytes');
 require('@ethersproject/logger');