@leofcoin/workers 1.3.10 → 1.3.12

package/package.json

@@ -1,25 +1,26 @@
-{
-  "name": "@leofcoin/workers",
-  "version": "1.3.10",
-  "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/utils": "^1.1.5",
-    "@vandeurenglenn/easy-worker": "^1.0.2"
-  }
-}
+{
+  "name": "@leofcoin/workers",
+  "version": "1.3.12",
+  "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"
+  }
+}

package/src/block-worker.js

@@ -1,31 +1,31 @@
-import { BlockMessage } from '@leofcoin/messages'
-import { formatBytes, BigNumber } from '@leofcoin/utils'
-
-import EasyWorker from '@vandeurenglenn/easy-worker'
-
-const worker = new EasyWorker()
-
-globalThis.BigNumber = BigNumber
-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 => {  
-  blocks = await run(blocks)
-  worker.postMessage(blocks)
-}
- 
-
-worker.onmessage(data => tasks(data))
-
+import { BlockMessage } from '@leofcoin/messages'
+import { formatBytes, BigNumber } from '@leofcoin/utils'
+
+import EasyWorker from '@vandeurenglenn/easy-worker'
+
+const worker = new EasyWorker()
+
+globalThis.BigNumber = BigNumber
+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 => {  
+  blocks = await run(blocks)
+  worker.postMessage(blocks)
+}
+ 
+
+worker.onmessage(data => tasks(data))
+

package/src/log-worker.ts

@@ -0,0 +1,51 @@
+import { BlockMessage } from '@leofcoin/messages'
+import { formatBytes, BigNumber } from '@leofcoin/utils'
+
+import EasyWorker from '@vandeurenglenn/easy-worker'
+import Storage from '@leofcoin/storage'
+const worker = new EasyWorker()
+const logStore = new Storage('log')
+await logStore.init()
+
+declare type messageType = 'put' | 'get'
+
+declare type message = {
+  type: messageType,
+  input: string
+}
+
+declare type messageReturn = {
+  type: messageType,
+  result?: string,
+  message?: string,
+  error?: Error
+}
+
+const handlePut = async message => {
+  try {
+    await fetch(`http://localhost:8080/log/put`, {
+      method: 'put',
+      body: message
+    })
+  } catch (error) {
+    worker.postMessage({ type: 'logError', message, error })
+  }
+}
+
+const handleGet = async message => {
+  try {
+    await fetch(`http://localhost:8080/log/get?`, {
+      method: 'put',
+      body: message
+    })
+  } catch (error) {
+    worker.postMessage({ type: 'logError', message, error })
+  }
+}
+
+worker.onmessage((message: message) => {
+  if (!message.type) message.type = 'put'
+  if (message.type === 'put') handlePut(message.input)
+  else handleGet(message.input)
+})
+

package/src/machine-worker.js

@@ -1,222 +1,222 @@
-import { BlockMessage, ContractMessage } from '@leofcoin/messages'
-import { formatBytes, BigNumber } from '@leofcoin/utils'
-import bytecodes  from '@leofcoin/lib/bytecodes' assert {type: 'json'}
-import EasyWorker from '@vandeurenglenn/easy-worker'
-const worker = new EasyWorker()
-
-const contractFactoryMessage = bytecodes.contractFactory
-const nativeTokenMessage = bytecodes.nativeToken
-const nameServiceMessage = bytecodes.nameService
-const validatorsMessage = bytecodes.validators
-
-globalThis.BigNumber = BigNumber
-globalThis.contracts = {}
-
-const unique = arr => arr.filter((el, pos, arr) => {
-  return arr.indexOf(el) == pos;
-})
-
-const has = address => {
-  return contracts[address] ? true : false
-}
-
-const get = (contract, method, params) => {
-  let result
-  if (params?.length > 0) {
-    result = contracts[contract][method](...params)
-  } else {
-    result = contracts[contract][method]
-  }
-  return result
-}
-
-const runContract = async ({decoded, hash, encoded}) => {
-  const params = decoded.constructorParameters
-  try {
-
-    const func = new Function(new TextDecoder().decode(contract))
-    const Contract = func()
-
-    globalThis.msg = createMessage(decoded.creator)
-    contracts[hash] = await new Contract(...params)
-    worker.postMessage({
-      type: 'debug',
-      messages: [
-        `loaded contract: ${hash}`,
-        `size: ${formatBytes(encoded.length)}`
-      ]
-    })
-  } catch (e) {
-    console.log(e);
-    worker.postMessage({
-      type: 'contractError',
-      hash: await contractMessage.hash()
-    })
-  }
-}
-
-const execute = async (contract, method, params) => {
-  try {
-    let result
-    // don't execute the method on a proxy
-    if (contracts[contract].fallback) {
-      result = await contracts[contract].fallback(method, params)
-    } else {
-      result = await contracts[contract][method](...params)
-    }
-    // state.put(result)
-    return result
-  } catch (e) {
-    throw e
-  }
-}
-
-
-const createMessage = (sender = globalThis.peerid) => {
-  return {
-    sender,
-    call: execute,
-    staticCall: get
-  }
-}
-
-const _init = async ({ contracts, blocks, peerid })=> {
-
-  globalThis.peerid = peerid
-  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
-  }))
-
-  let lastBlock = {hash: '0x0'}; 
-
-  if (blocks?.length > 0) {
-    const _worker = await new EasyWorker('node_modules/@leofcoin/workers/src/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++) {
-
-    // }
-    // 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
-    //     }
-    //   }));
-    // }
-    
-    if (blocks.length > 0) {
-      lastBlock = blocks[blocks.length - 1].decoded;    
-      lastBlock = await new BlockMessage(lastBlock);
-  
-      lastBlock = {
-        ...lastBlock.decoded,
-        hash: await lastBlock.hash()
-      };
-    }
-    globalThis.blocks = blocks
-  }
-
-  
-
-  
-  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 === '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 === '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
-          
-        })
-      }
-    }
-  }
-
+import { BlockMessage, ContractMessage } from '@leofcoin/messages'
+import { formatBytes, BigNumber } from '@leofcoin/utils'
+import bytecodes  from '@leofcoin/lib/bytecodes' assert {type: 'json'}
+import EasyWorker from '@vandeurenglenn/easy-worker'
+const worker = new EasyWorker()
+
+const contractFactoryMessage = bytecodes.contractFactory
+const nativeTokenMessage = bytecodes.nativeToken
+const nameServiceMessage = bytecodes.nameService
+const validatorsMessage = bytecodes.validators
+
+globalThis.BigNumber = BigNumber
+globalThis.contracts = {}
+
+const unique = arr => arr.filter((el, pos, arr) => {
+  return arr.indexOf(el) == pos;
+})
+
+const has = address => {
+  return contracts[address] ? true : false
+}
+
+const get = (contract, method, params) => {
+  let result
+  if (params?.length > 0) {
+    result = contracts[contract][method](...params)
+  } else {
+    result = contracts[contract][method]
+  }
+  return result
+}
+
+const runContract = async ({decoded, hash, encoded}) => {
+  const params = decoded.constructorParameters
+  try {
+
+    const func = new Function(new TextDecoder().decode(decoded.contract))
+    const Contract = func()
+
+    globalThis.msg = createMessage(decoded.creator)
+    contracts[hash] = await new Contract(...params)
+    worker.postMessage({
+      type: 'debug',
+      messages: [
+        `loaded contract: ${hash}`,
+        `size: ${formatBytes(encoded.length)}`
+      ]
+    })
+  } catch (e) {
+    console.log(e);
+    worker.postMessage({
+      type: 'contractError',
+      hash: await contractMessage.hash()
+    })
+  }
+}
+
+const execute = async (contract, method, params) => {
+  try {
+    let result
+    // don't execute the method on a proxy
+    if (contracts[contract].fallback) {
+      result = await contracts[contract].fallback(method, params)
+    } else {
+      result = await contracts[contract][method](...params)
+    }
+    // state.put(result)
+    return result
+  } catch (e) {
+    throw e
+  }
+}
+
+
+const createMessage = (sender = globalThis.peerid) => {
+  return {
+    sender,
+    call: execute,
+    staticCall: get
+  }
+}
+
+const _init = async ({ contracts, blocks, peerid })=> {
+
+  globalThis.peerid = peerid
+  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
+  }))
+
+  let lastBlock = {hash: '0x0'}; 
+
+  if (blocks?.length > 0) {
+    const _worker = await new EasyWorker('node_modules/@leofcoin/workers/src/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++) {
+
+    // }
+    // 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
+    //     }
+    //   }));
+    // }
+    
+    if (blocks.length > 0) {
+      lastBlock = blocks[blocks.length - 1].decoded;    
+      lastBlock = await new BlockMessage(lastBlock);
+  
+      lastBlock = {
+        ...lastBlock.decoded,
+        hash: await lastBlock.hash()
+      };
+    }
+    globalThis.blocks = blocks
+  }
+
+  
+
+  
+  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 === '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 === '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
+          
+        })
+      }
+    }
+  }
+
 worker.onmessage(data => tasks(data))

package/src/pool-worker.js

@@ -1,19 +1,19 @@
-import { TransactionMessage } from '@leofcoin/messages'
-
-import EasyWorker from '@vandeurenglenn/easy-worker'
-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}
-  }))
-
-  worker.postMessage(transactions)
-  
-}
- worker.onmessage(data => tasks(data))
+import { TransactionMessage } from '@leofcoin/messages'
+
+import EasyWorker from '@vandeurenglenn/easy-worker'
+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}
+  }))
+
+  worker.postMessage(transactions)
+  
+}
+ worker.onmessage(data => tasks(data))

package/src/transaction-worker.js

@@ -1,12 +1,12 @@
-import { TransactionMessage } from '@leofcoin/messages'
-globalThis.contracts = {}
-
-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)))
-
-  worker.postMessage(transactions)
+import { TransactionMessage } from '@leofcoin/messages'
+globalThis.contracts = {}
+
+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)))
+
+  worker.postMessage(transactions)
 })

package/src/workers.js

@@ -1,9 +1,9 @@
-import * as transactionWorker from './transaction-worker.js'
-import * as blockWorker from './block-worker.js'
-import * as poolWorker from './pool-worker.js'
-import * as machineWorker from './machine-worker.js'
-
-export const TransactionWorker = transactionWorker
-export const BlockWorker = blockWorker
-export const PoolWorker = poolWorker
+import * as transactionWorker from './transaction-worker.js'
+import * as blockWorker from './block-worker.js'
+import * as poolWorker from './pool-worker.js'
+import * as machineWorker from './machine-worker.js'
+
+export const TransactionWorker = transactionWorker
+export const BlockWorker = blockWorker
+export const PoolWorker = poolWorker
 export const MachineWorker = machineWorker