@leofcoin/workers 1.3.15 → 1.3.18

package/package.json

@@ -1,26 +1,27 @@
-{
-  "name": "@leofcoin/workers",
-  "version": "1.3.15",
-  "description": "Workers used in @leofcoin/chain",
-  "type": "module",
-  "exports": {
-    ".": "./src/workers.js",
-    "./machine-worker": "./src/machine-worker.js",
-    "./block-worker": "./src/block-worker.js",
-    "./transaction-worker": "./src/transaction-worker.js",
-    "./pool-worker": "./src/pool-worker.js"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "author": "",
-  "license": "MIT",
-  "dependencies": {
-    "@leofcoin/lib": "^1.2.3",
-    "@leofcoin/messages": "^1.2.0",
-    "@leofcoin/storage": "^3.3.2",
-    "@leofcoin/utils": "^1.1.5",
-    "@vandeurenglenn/easy-worker": "^1.0.2"
-  }
-}
+{
+  "name": "@leofcoin/workers",
+  "version": "1.3.18",
+  "description": "Workers used in @leofcoin/chain",
+  "type": "module",
+  "exports": {
+    ".": "./src/workers.js",
+    "./machine-worker": "./src/machine-worker.js",
+    "./block-worker": "./src/block-worker.js",
+    "./transaction-worker": "./src/transaction-worker.js",
+    "./pool-worker": "./src/pool-worker.js"
+  },
+  "scripts": {
+    "prettier": "prettier src --config ./../../.prettierrc --write",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@leofcoin/lib": "^1.2.3",
+    "@leofcoin/messages": "^1.2.0",
+    "@leofcoin/storage": "^3.3.2",
+    "@leofcoin/utils": "^1.1.5",
+    "@vandeurenglenn/easy-worker": "^1.0.2"
+  }
+}

package/src/block-worker.js

@@ -8,24 +8,29 @@ const worker = new EasyWorker()
 globalThis.BigNumber = BigNumber
 globalThis.contracts = {}
 
-const run = async (blocks) => {  
-  blocks = await Promise.all(blocks.map(block => new BlockMessage(block)))
+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)
-  })))
+  blocks = await Promise.all(
+    blocks.map(
+      (block) =>
+        new Promise(async (resolve, reject) => {
+          // todo: tx worker or nah?
+          await block.encode()
+          const size = block.encoded.length || block.encoded.byteLength
+          console.log(`loaded block: ${await block.hash()} @${block.decoded.index} ${formatBytes(size)}`)
+          // todo we don't want this, need shared state
+          resolve(block.decoded)
+        })
+    )
+  )
   return blocks
 }
 
-const tasks = async blocks => {  
+const tasks = async (blocks) => {
   blocks = await run(blocks)
   worker.postMessage(blocks)
 }
- 
-
-worker.onmessage(data => tasks(data))
 
+worker.onmessage((data) => tasks(data))

package/src/log-worker.ts

@@ -10,18 +10,18 @@ await logStore.init()
 declare type messageType = 'put' | 'get'
 
 declare type message = {
-  type: messageType,
+  type: messageType
   input: string
 }
 
 declare type messageReturn = {
-  type: messageType,
-  result?: string,
-  message?: string,
+  type: messageType
+  result?: string
+  message?: string
   error?: Error
 }
 
-const handlePut = async message => {
+const handlePut = async (message) => {
   try {
     await fetch(`http://localhost:8844/log/put`, {
       method: 'put',
@@ -32,7 +32,7 @@ const handlePut = async message => {
   }
 }
 
-const handleGet = async message => {
+const handleGet = async (message) => {
   try {
     await fetch(`http://localhost:8844/log/get?`, {
       method: 'put',
@@ -48,4 +48,3 @@ worker.onmessage((message: message) => {
   if (message.type === 'put') handlePut(message.input)
   else handleGet(message.input)
 })
-

package/src/machine-worker.js

@@ -1,6 +1,6 @@
 import { BlockMessage, ContractMessage } from '@leofcoin/messages'
 import { formatBytes, BigNumber } from '@leofcoin/utils'
-import bytecodes  from '@leofcoin/lib/bytecodes' assert {type: 'json'}
+import bytecodes from '@leofcoin/lib/bytecodes' assert { type: 'json' }
 import EasyWorker from '@vandeurenglenn/easy-worker'
 const worker = new EasyWorker()
 
@@ -12,11 +12,12 @@ const validatorsMessage = bytecodes.validators
 globalThis.BigNumber = BigNumber
 globalThis.contracts = {}
 
-const unique = arr => arr.filter((el, pos, arr) => {
-  return arr.indexOf(el) == pos;
-})
+const unique = (arr) =>
+  arr.filter((el, pos, arr) => {
+    return arr.indexOf(el) == pos
+  })
 
-const has = address => {
+const has = (address) => {
   return contracts[address] ? true : false
 }
 
@@ -30,10 +31,9 @@ const get = (contract, method, params) => {
   return result
 }
 
-const runContract = async ({decoded, hash, encoded}) => {
+const runContract = async ({ decoded, hash, encoded }) => {
   const params = decoded.constructorParameters
   try {
-
     const func = new Function(new TextDecoder().decode(decoded.contract))
     const Contract = func()
 
@@ -41,13 +41,10 @@ const runContract = async ({decoded, hash, encoded}) => {
     contracts[hash] = await new Contract(...params)
     worker.postMessage({
       type: 'debug',
-      messages: [
-        `loaded contract: ${hash}`,
-        `size: ${formatBytes(encoded.length)}`
-      ]
+      messages: [`loaded contract: ${hash}`, `size: ${formatBytes(encoded.length)}`]
     })
   } catch (e) {
-    console.log(e);
+    console.log(e)
     worker.postMessage({
       type: 'contractError',
       hash: await contractMessage.hash()
@@ -77,7 +74,6 @@ const execute = async (contract, method, params) => {
   }
 }
 
-
 const createMessage = (sender = globalThis.peerid) => {
   return {
     sender,
@@ -86,23 +82,19 @@ const createMessage = (sender = globalThis.peerid) => {
   }
 }
 
-const _init = async ({ contracts, blocks, peerid })=> {
-
+const _init = async ({ contracts, blocks, peerid }) => {
   globalThis.peerid = peerid
-  contracts = [
-    contractFactoryMessage,
-    nativeTokenMessage,
-    nameServiceMessage,
-    validatorsMessage
-  ]
+  contracts = [contractFactoryMessage, nativeTokenMessage, nameServiceMessage, validatorsMessage]
 
-  contracts = await Promise.all(contracts.map(async contract => {
-    contract = await new ContractMessage(new Uint8Array(contract.split(',')))
-    await runContract({decoded: contract.decoded, encoded: contract.encoded, hash: await contract.hash()})
-    return contract
-  }))
+  contracts = await Promise.all(
+    contracts.map(async (contract) => {
+      contract = await new ContractMessage(new Uint8Array(contract.split(',')))
+      await runContract({ decoded: contract.decoded, encoded: contract.encoded, hash: await contract.hash() })
+      return contract
+    })
+  )
 
-  let lastBlock = {hash: '0x0'}; 
+  let lastBlock = { hash: '0x0' }
 
   if (blocks?.length > 0) {
     let pre
@@ -110,15 +102,18 @@ const _init = async ({ contracts, blocks, peerid })=> {
     try {
       const importee = await import('url')
       const url = importee.default
-      if (url) pre = url.fileURLToPath(new URL('.', import.meta.url));
+      if (url) pre = url.fileURLToPath(new URL('.', import.meta.url))
     } catch {
       // browser env
       pre = './'
     }
 
-    const _worker = await new EasyWorker(pre + '@leofcoin/workers/block-worker.js', {serialization: 'advanced', type: 'module' })
+    const _worker = await new EasyWorker(pre + '@leofcoin/workers/block-worker.js', {
+      serialization: 'advanced',
+      type: 'module'
+    })
     blocks = await _worker.once([blocks[blocks.length - 1]])
-    
+
     // blocks = unique(globalThis.blocks ? globalThis : [], blocks)
     // for (let i = 0; i < blocks.length; i++) {
 
@@ -128,112 +123,108 @@ const _init = async ({ contracts, blocks, peerid })=> {
     //     if (!block.loaded) {
     //       const {from, to, method, params} = message;
     //       globalThis.msg = createMessage(from);
-        
+
     //       await execute(to, method, params);
     //       block.loaded = true
     //     }
     //   }));
     // }
-    
+
     if (blocks.length > 0) {
-      lastBlock = blocks[blocks.length - 1].decoded;    
-      lastBlock = await new BlockMessage(lastBlock);
-  
+      lastBlock = blocks[blocks.length - 1]
+      // todo blocks already loaded as blockmessage so use it!
+      lastBlock = await new BlockMessage(lastBlock)
+
       lastBlock = {
         ...lastBlock.decoded,
         hash: await lastBlock.hash()
-      };
+      }
     }
     globalThis.blocks = blocks
   }
 
-  
+  worker.postMessage({ type: 'machine-ready', lastBlock })
 
-  
-  worker.postMessage({type: 'machine-ready', lastBlock});
-  
   // worker.postMessage({blocks});
 }
 
 const tasks = async (e) => {
   const id = e.id
-    if (e.type === 'init') {
-      try {
-        await _init(e.input)
-      } catch (e) {
-        worker.postMessage({
-          type: 'initError',
-          message: e.message,
-          id          
-        })
-      }
+  if (e.type === 'init') {
+    try {
+      await _init(e.input)
+    } catch (e) {
+      worker.postMessage({
+        type: 'initError',
+        message: e.message,
+        id
+      })
     }
-    if (e.type === 'has') {
-      try {
-        const value = await has(e.input.address)
-        worker.postMessage({
-          type: 'response',
-          id,
-          value
-        })
-      } catch (error) {
-        worker.postMessage({
-          type: 'hasError',
-          message: error.message,
-          id          
-        })
-      }
+  }
+  if (e.type === 'has') {
+    try {
+      const value = await has(e.input.address)
+      worker.postMessage({
+        type: 'response',
+        id,
+        value
+      })
+    } catch (error) {
+      worker.postMessage({
+        type: 'hasError',
+        message: error.message,
+        id
+      })
     }
-    if (e.type === 'run') {
-      try {
-        const value = await runContract(e.input)
-        worker.postMessage({
-          type: 'response',
-          id,
-          value
-        })
-      } catch (e) {
-        worker.postMessage({
-          type: 'runError',
-          message: e.message,
-          id          
-        })
-      }
+  }
+  if (e.type === 'run') {
+    try {
+      const value = await runContract(e.input)
+      worker.postMessage({
+        type: 'response',
+        id,
+        value
+      })
+    } catch (e) {
+      worker.postMessage({
+        type: 'runError',
+        message: e.message,
+        id
+      })
     }
-    if (e.type === 'get') {
-      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 === 'get') {
+    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 {
-        const value = await execute(e.input.contract, e.input.method, e.input.params)
-        worker.postMessage({
-          type: 'response',
-          id,
-          value
-        })
-      } catch(e) {
-        worker.postMessage({
-          type: 'executionError',
-          message: e.message,
-          id
-          
-        })
-      }
+  }
+  if (e.type === 'execute') {
+    try {
+      const value = await execute(e.input.contract, e.input.method, e.input.params)
+      worker.postMessage({
+        type: 'response',
+        id,
+        value
+      })
+    } catch (e) {
+      worker.postMessage({
+        type: 'executionError',
+        message: e.message,
+        id
+      })
     }
   }
+}
 
-worker.onmessage(data => tasks(data))
+worker.onmessage((data) => tasks(data))

package/src/pool-worker.js

@@ -5,15 +5,15 @@ globalThis.contracts = {}
 
 const worker = new EasyWorker()
 
-const tasks = async transactions => {
-  
-  transactions = await Promise.all(transactions.map(async message => {
-    message = await new TransactionMessage(message)
-    
-    return {...message.decoded, hash: await message.hash(), size: message.encoded.length}
-  }))
+const tasks = async (transactions) => {
+  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))
+worker.onmessage((data) => tasks(data))

package/src/transaction-worker.js

@@ -6,7 +6,7 @@ import EasyWorker from '@vandeurenglenn/easy-worker'
 const worker = new EasyWorker()
 
 worker.onmessage(async (transactions) => {
-  transactions = await Promise.all(transactions.map(async message => new TransactionMessage(message)))
+  transactions = await Promise.all(transactions.map(async (message) => new TransactionMessage(message)))
 
   worker.postMessage(transactions)
-})
+})

package/src/workers.js

@@ -6,4 +6,4 @@ import * as machineWorker from './machine-worker.js'
 export const TransactionWorker = transactionWorker
 export const BlockWorker = blockWorker
 export const PoolWorker = poolWorker
-export const MachineWorker = machineWorker
+export const MachineWorker = machineWorker