@leofcoin/workers 1.3.16 → 1.3.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/workers",
-  "version": "1.3.16",
+  "version": "1.3.19",
   "description": "Workers used in @leofcoin/chain",
   "type": "module",
   "exports": {
@@ -11,6 +11,7 @@
     "./pool-worker": "./src/pool-worker.js"
   },
   "scripts": {
+    "prettier": "prettier src --config ./../../.prettierrc --write",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [],

package/src/block-worker.js

@@ -1,33 +1,36 @@
-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?
-    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 => {  
-  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?
+          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) => {
+  blocks = await run(blocks)
+  worker.postMessage(blocks)
+}
+
+worker.onmessage((data) => tasks(data))

package/src/log-worker.ts

@@ -1,51 +1,50 @@
-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:8844/log/put`, {
-      method: 'put',
-      body: message
-    })
-  } catch (error) {
-    worker.postMessage({ type: 'logError', message, error })
-  }
-}
-
-const handleGet = async message => {
-  try {
-    await fetch(`http://localhost:8844/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)
-})
-
+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:8844/log/put`, {
+      method: 'put',
+      body: message
+    })
+  } catch (error) {
+    worker.postMessage({ type: 'logError', message, error })
+  }
+}
+
+const handleGet = async (message) => {
+  try {
+    await fetch(`http://localhost:8844/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,240 +1,230 @@
-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 new Error(
-      `error: ${e.message}
-      contract: ${contract}
-      method: ${method}
-      params: ${JSON.stringify(params, null, '\t')}
-      `
-    )
-  }
-}
-
-
-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) {
-    let pre
-
-    try {
-      const importee = await import('url')
-      const url = importee.default
-      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' })
-    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];
-      // 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({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))
+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 new Error(
+      `error: ${e.message}
+      contract: ${contract}
+      method: ${method}
+      params: ${JSON.stringify(params, null, '\t')}
+      `
+    )
+  }
+}
+
+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) {
+    let pre
+
+    try {
+      const importee = await import('url')
+      const url = importee.default
+      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'
+    })
+    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]
+      // 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({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
-export const MachineWorker = machineWorker
+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