@leofcoin/chain 1.1.10 → 1.1.12

package/dist/module/chain.js

@@ -53,7 +53,7 @@ const formatBytes = (bytes, decimals = 2) => {
 class Machine {
   #contracts = {}
   #nonces = {}
-  lastBlock = {}
+  lastBlock = {index: 0, hash: '0x0', previousHash: '0x0'}
 
   constructor() {
     return this.#init()
@@ -84,7 +84,7 @@ class Machine {
       break
       case 'machine-ready':
         this.lastBlock = data.lastBlock;
-        pubsub.publish('machine.ready');
+        pubsub.publish('machine.ready', true);
       break
       case 'response':
         pubsub.publish(data.id, data.value);
@@ -205,6 +205,10 @@ class Machine {
     return contractStore.delete(hash)
   }
 
+  /**
+   * 
+   * @returns Promise
+   */
   async deleteAll() {
     let hashes = await contractStore.get();
     hashes = Object.keys(hashes).map(hash => this.delete(hash));
@@ -480,20 +484,41 @@ class Chain {
     // handle native contracts
   }
 
+  promiseRequests(promises) {
+    return new Promise(async (resolve, reject) => {
+      const timeout = setTimeout(() => {
+        resolve([{index: 0, hash: '0x0'}]);
+        debug('sync timed out');
+      }, 10000);
+  
+      promises = await Promise.allSettled(promises);
+      promises = promises.filter(({status}) => status === 'fulfilled');
+      clearTimeout(timeout);
+
+      promises = promises.map(({value}) => new peernet.protos['peernet-response'](value));
+      promises = await Promise.all(promises);
+      promises = promises.map(node => node.decoded.response);      
+      resolve(promises);
+    })
+    
+  }
+
+  sync() {
+    return this.#sync()
+  }
+
   async #sync() {
     let promises = [];
+    
+    let data = await new peernet.protos['peernet-request']({request: 'lastBlock'});
+    const node = await peernet.prepareMessage(data);
+
     for (const peer of peernet.connections) {
-      if (peer.peerId !== this.id) {
-        let data = await new peernet.protos['peernet-request']({request: 'lastBlock'});
-        const node = await peernet.prepareMessage(data);
+      if (peer.connected && peer.readyState === 'open' && peer.peerId !== this.id) {        
         promises.push(peer.request(node.encoded));
-      }
+      } else if (!peer.connected || peer.readyState !== 'open') ;
     }
-    promises = await Promise.allSettled(promises);
-    promises = promises.filter(({status}) => status === 'fulfilled');
-    promises = promises.map(({value}) => new peernet.protos['peernet-response'](value));
-    promises = await Promise.all(promises);
-    promises = promises.map(node => node.decoded.response);
+    promises = await this.promiseRequests(promises);
     promises = promises.reduce((set, value) => {
       
       if (value.index > set.index) {
@@ -504,8 +529,7 @@ class Chain {
     }, {index: 0, hash: '0x0'});
     // get lastblock
       if (promises.hash && promises.hash !== '0x0') {
-        let localBlock = await peernet.get(promises.hash);
-        console.log({localBlock});
+        await peernet.get(promises.hash);
       }
       
       
@@ -520,22 +544,7 @@ class Chain {
 
     this.#machine = await new Machine();
     this.utils = { BigNumber, formatUnits, parseUnits };
-
-    await peernet.addRequestHandler('bw-request-message', () => {
-
-      return new BWMessage(peernet.client.bw) || { up: 0, down: 0 }
-    });
-
-    await peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
-
-    peernet.subscribe('add-block', this.#addBlock.bind(this));
-
-    peernet.subscribe('add-transaction', this.#addTransaction.bind(this));
-
-    peernet.subscribe('validator:timeout', this.#validatorTimeout.bind(this));
-
-    pubsub.subscribe('peer:connected', this.#peerConnected.bind(this));
-
+    
     try {
       let localBlock;
       try {
@@ -545,17 +554,11 @@ class Chain {
         localBlock = await chainStore.get('lastBlock');
       }
       localBlock = new TextDecoder().decode(localBlock);
-
       if (localBlock && localBlock !== '0x0') {
-        localBlock = await peernet.get(localBlock);
+        localBlock = await peernet.get(localBlock, 'block');
         localBlock = await new BlockMessage(localBlock);
         this.#lastBlock = {...localBlock.decoded, hash: await localBlock.hash};
-      } else if (this.#machine.lastBlock?.hash) {
-        // todo remove when network is running
-        // recovering chain (not needed if multiple peers are online)
-        this.#lastBlock = this.#machine.lastBlock;
-        await chainStore.put('lastBlock', this.#lastBlock.hash);
-      } else  {
+      } else {
         await this.#sync();
       }      
     } catch (e) {
@@ -564,8 +567,25 @@ class Chain {
 
       // this.#setup()
     }
+
+    await peernet.addRequestHandler('bw-request-message', () => {
+
+      return new BWMessage(peernet.client.bw) || { up: 0, down: 0 }
+    });
+
+    await peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this));
+
+    peernet.subscribe('add-block', this.#addBlock.bind(this));
+
+    peernet.subscribe('add-transaction', this.#addTransaction.bind(this));
+
+    peernet.subscribe('validator:timeout', this.#validatorTimeout.bind(this));
+
+    pubsub.subscribe('peer:connected', this.#peerConnected.bind(this));
+
+    
     // load local blocks
-    if (peernet.connections?.length > 1) await this.resolveBlocks();
+    await this.resolveBlocks();
     return this
   }
 
@@ -583,7 +603,7 @@ class Chain {
     response = await new globalThis.peernet.protos['peernet-response'](response);
     let lastBlock = response.decoded.response;
 
-    if (!this.lastBlock || this.lastBlock.index < lastBlock.index) {
+    if (!this.lastBlock || Number(this.lastBlock.index) < Number(lastBlock.index)) {
          // TODO: check if valid
       const localIndex = this.lastBlock ? this.lastBlock.index : 0;
       const index = lastBlock.index;
@@ -625,7 +645,8 @@ async resolveBlock(hash) {
   if (!await peernet.has(hash, 'block')) await peernet.put(hash, block.encoded, 'block');
   const size = block.encoded.length || block.encoded.byteLength;
   block = {...block.decoded, hash};
-  this.#blocks[block.index - 1] = block;
+  if (this.#blocks[block.index]) throw `invalid block ${hash} @${block.index}`
+  this.#blocks[block.index] = block;
   console.log(`loaded block: ${hash} @${block.index} ${formatBytes(size)}`);
   if (block.previousHash !== '0x0') {
     return this.resolveBlock(block.previousHash)
@@ -634,11 +655,11 @@ async resolveBlock(hash) {
 
   async resolveBlocks() {
     try {
-
       const localBlock = await chainStore.get('lastBlock');
       const hash = new TextDecoder().decode(localBlock);
+
       if (hash && hash !== '0x0')
-        await this.resolveBlock(localBlock);
+        await this.resolveBlock(hash);
         this.#lastBlock = this.#blocks[this.#blocks.length - 1];
         await this.#loadBlocks(this.#blocks);
     } catch (e) {
@@ -695,7 +716,8 @@ async resolveBlock(hash) {
   }
 
   async #addBlock(block) {
-    const blockMessage = await new BlockMessage(block);
+    // console.log(block);
+    const blockMessage = await new BlockMessage(new Uint8Array(Object.values(block)));
     // if (!Buffer.isBuffer(block)) block = Buffer.from(block, 'hex')
     // const transactionJob = async transaction => {
     //   try {
@@ -710,14 +732,17 @@ async resolveBlock(hash) {
     //   transaction = new TransactionMessage(transaction)
     //   return transaction
     // }
+
+    console.log(blockMessage);
     await Promise.all(blockMessage.decoded.transactions
       .map(async transaction => transactionPoolStore.delete(await transaction.hash)));
     const hash = await blockMessage.hash;
     // let transactions = blockMessage.decoded.transactions.map(tx => transactionJob(tx))
     // transactions = await Promise.all(transactions)
-    this.#lastBlock = { hash, ...blockMessage.decoded };
+    
     await blockStore.put(hash, blockMessage.encoded);
-    await chainStore.put('lastBlock', hash);
+    
+    if (this.lastBlock.index < blockMessage.decoded.index) await this.#updateState(blockMessage);
     debug(`added block: ${hash}`);
     let promises = [];
     let contracts = [];
@@ -739,6 +764,8 @@ async resolveBlock(hash) {
       //   // await stateStore.put(contract, state)
       //   console.log(state);
       // }
+
+      
       pubsub.publish('block-processed', blockMessage.decoded);
     } catch (e) {
       console.log({e});
@@ -746,8 +773,10 @@ async resolveBlock(hash) {
 
   }
 
-  async #updateState() {
-    
+  async #updateState(message) {
+    const hash = await message.hash;
+    this.#lastBlock = { hash, ...message.decoded };
+    await chainStore.put('lastBlock', hash);
   }
 
 
@@ -909,13 +938,11 @@ async resolveBlock(hash) {
       const hash = await blockMessage.hash;
       
       
-      this.#lastBlock = { hash, ...blockMessage.decoded };
-      await blockStore.put(hash, blockMessage.encoded);
-      await chainStore.put('lastBlock', hash);
+      await peernet.put(hash, blockMessage.encoded, 'block');
+      await this.#updateState(blockMessage);
       debug(`created block: ${hash}`);
 
       peernet.publish('add-block', blockMessage.encoded);
-      this.#updateState(blockMessage);
     } catch (e) {
       console.log(e);
       throw Error(`invalid block ${block}`)

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

@@ -1,7 +1,7 @@
 import { FormatInterface } from '@leofcoin/codec-format-interface';
 import { BigNumber } from '@ethersproject/bignumber';
 import '@ethersproject/units';
-import { join } from 'path';
+import 'path';
 import EasyWorker from '@vandeurenglenn/easy-worker';
 
 var proto$1 = `
@@ -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('./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);
+});