@leofcoin/workers 1.3.19 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/workers",
-  "version": "1.3.19",
+  "version": "1.4.0",
   "description": "Workers used in @leofcoin/chain",
   "type": "module",
   "exports": {

package/src/block-worker.js

@@ -19,9 +19,11 @@ const run = async (blocks) => {
           // 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)}`)
+          const hash = await block.hash()
+          const index = block.decoded.index
+          console.log(`loaded block: ${hash} @${index} ${formatBytes(size)}`)
           // todo we don't want this, need shared state
-          resolve(block.decoded)
+          resolve({ ...block.decoded, blockInfo: { hash, size, index } })
         })
     )
   )

package/src/chain-worker.ts

@@ -0,0 +1,42 @@
+import { BlockMessage } from '@leofcoin/messages'
+import { formatBytes, BigNumber } from '@leofcoin/utils'
+
+import EasyWorker from '@vandeurenglenn/easy-worker'
+
+declare type messageType = 'put' | 'get'
+
+declare type message = {
+  type: messageType
+  input: string
+}
+
+declare type messageReturn = {
+  type: messageType
+  result?: string
+  message?: string
+  error?: Error
+}
+
+const _addBlock = (block) => {
+  blocks[block.index - 1] = block
+}
+
+const _getBlocks = (index = 0) => {
+  worker.postMessage({ type: 'getBlock', result: blocks.slice(index - 1, blocks.length - 1) })
+}
+
+const _getBlock = (index) => {
+  worker.postMessage({ type: 'getBlock', result: blocks[index - 1] })
+}
+
+const _init = (_blocks) => {
+  blocks = _blocks
+  try {
+  } catch (error) {}
+  worker.postMessage({ type: 'init', result: 'ready' })
+}
+
+worker.onmessage((message: message) => {
+  if (!message.type) message.type = 'init'
+  _[message.type](message.input)
+})

package/src/machine-worker.js

@@ -108,27 +108,47 @@ const _init = async ({ contracts, blocks, peerid }) => {
       pre = './'
     }
 
-    const _worker = await new EasyWorker(pre + '@leofcoin/workers/block-worker.js', {
+    let _worker = await new EasyWorker(pre + '@leofcoin/workers/block-worker.js', {
       serialization: 'advanced',
       type: 'module'
     })
-    blocks = await _worker.once([blocks[blocks.length - 1]])
-
+    blocks = await _worker.once(blocks)
+    console.log({ blocks })
+    _worker = null
     // blocks = unique(globalThis.blocks ? globalThis : [], blocks)
     // for (let i = 0; i < blocks.length; i++) {
 
     // }
-    // for (const block of blocks) {
-    //   await Promise.all(block.decoded.transactions.map(async message => {
-    //     if (!block.loaded) {
-    //       const {from, to, method, params} = message;
-    //       globalThis.msg = createMessage(from);
-
-    //       await execute(to, method, params);
-    //       block.loaded = true
-    //     }
-    //   }));
-    // }
+    for (const block of blocks) {
+      try {
+        await Promise.all(
+          block.transactions.map(async (message) => {
+            if (!block.loaded) {
+              const { from, to, method, params } = message
+              globalThis.msg = createMessage(from)
+
+              try {
+                await execute(to, method, params)
+              } catch (error) {
+                throw error
+              }
+            }
+          })
+        )
+        block.loaded = true
+        worker.postMessage({
+          type: 'debug',
+          message: `loaded transactions for block: ${block.blockInfo.hash} @${block.blockInfo.index} ${formatBytes(
+            block.blockInfo.size
+          )}`
+        })
+      } catch (error) {
+        worker.postMessage({
+          type: 'error',
+          message: error.message
+        })
+      }
+    }
 
     if (blocks.length > 0) {
       lastBlock = blocks[blocks.length - 1]