@leofcoin/chain 1.1.10 → 1.1.11

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

@@ -0,0 +1,93 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BigNumber } from '@ethersproject/bignumber';
+import '@ethersproject/units';
+import EasyWorker from '@vandeurenglenn/easy-worker';
+
+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 byteFormats = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+
+const formatBytes = (bytes, decimals = 2) => {
+  if (bytes === 0) return '0 Bytes';
+  if (decimals < 0) decimals = 0;
+
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${byteFormats[i]}`
+};
+
+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));

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

@@ -124,7 +124,7 @@ const runContract = async (contractMessage) => {
     globalThis.msg = createMessage(contractMessage.decoded.creator);
     // globalThis.msg = {sender: contractMessage.decoded.creator}
     contracts[await contractMessage.hash] = await new Contract(...params);
-    process.send({
+    worker.postMessage({
       type: 'debug',
       messages: [
         `loaded contract: ${await contractMessage.hash}`,
@@ -133,7 +133,7 @@ const runContract = async (contractMessage) => {
     });
   } catch (e) {
     console.log(e);
-    process.send({
+    worker.postMessage({
       type: 'contractError',
       hash: await contractMessage.hash
     });
@@ -196,29 +196,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);
@@ -226,14 +233,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/workers/pool-worker.js

@@ -0,0 +1,55 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+import EasyWorker from '@vandeurenglenn/easy-worker';
+
+var proto = `
+
+message TransactionMessage {
+  required uint64 timestamp = 1;
+  required string from = 2;
+  required string to = 3;
+  required uint64 nonce = 4;
+  required string method = 5;
+  repeated string params = 6;
+  required string signature = 7;
+}
+`;
+
+class TransactionMessage extends FormatInterface {
+  get keys() {
+    return ['timestamp', 'from', 'to', 'nonce', 'method', 'params', 'signature']
+  }
+
+  get messageName() {
+    return 'TransactionMessage'
+  }
+
+  constructor(buffer) {
+    const name = 'transaction-message';
+    super(buffer, proto, {name});
+  }
+}
+
+globalThis.peernet = globalThis.peernet || {};
+globalThis.contracts = {};
+
+const worker = new EasyWorker();
+
+const tasks = async transactions => {
+  
+  globalThis.peernet.codecs =  {
+    'transaction-message': {
+      codec: parseInt('746d', 16),
+      hashAlg: 'keccak-256'
+    }
+  };
+  
+  transactions = await Promise.all(transactions.map(async message => {
+    message = await new TransactionMessage(message);
+    
+    return {...message.decoded, hash: await message.hash, size: message.encoded.length}
+  }));
+
+  worker.postMessage(transactions);
+  
+};
+ worker.onmessage(data => tasks(data));

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

@@ -0,0 +1,47 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+import EasyWorker from '@vandeurenglenn/easy-worker';
+
+var proto = `
+
+message TransactionMessage {
+  required uint64 timestamp = 1;
+  required string from = 2;
+  required string to = 3;
+  required uint64 nonce = 4;
+  required string method = 5;
+  repeated string params = 6;
+  required string signature = 7;
+}
+`;
+
+class TransactionMessage extends FormatInterface {
+  get keys() {
+    return ['timestamp', 'from', 'to', 'nonce', 'method', 'params', 'signature']
+  }
+
+  get messageName() {
+    return 'TransactionMessage'
+  }
+
+  constructor(buffer) {
+    const name = 'transaction-message';
+    super(buffer, proto, {name});
+  }
+}
+
+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);
+});