@leofcoin/workers 1.5.1 → 1.5.3

package/package.json

@@ -1,21 +1,28 @@
 {
   "name": "@leofcoin/workers",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "Workers used in @leofcoin/chain",
   "type": "module",
   "private": false,
   "exports": {
-    ".": "./src/workers.js",
-    "./machine-worker": "./src/machine-worker.js",
-    "./block-worker": "./src/block-worker.js",
+    "./machine-worker": {
+      "import": "./exports/machine-worker.js",
+      "types": "./exports/machine-worker.d.ts"
+    },
+    "./block-worker": "./exports/block-worker.js",
     "./transaction-worker": "./src/transaction-worker.js",
     "./pool-worker": "./src/pool-worker.js"
   },
+  "files": [
+    "exports",
+    "src/**/*.js"
+  ],
   "scripts": {
     "prettier": "prettier src --config ./../../.prettierrc --write",
     "test": "echo \"Error: no test specified\" && exit 1",
     "npm-check-updates": "npx npm-check-updates -i",
-    "check-dependencies": "npx depcheck"
+    "check-dependencies": "npx depcheck",
+    "build": "rollup -c --silent error --cache true"
   },
   "keywords": [],
   "author": "",
@@ -23,7 +30,7 @@
   "dependencies": {
     "@leofcoin/addresses": "^1.0.23",
     "@leofcoin/lib": "^1.2.43",
-    "@leofcoin/messages": "^1.4.13",
+    "@leofcoin/messages": "^1.4.15",
     "@leofcoin/storage": "^3.5.28",
     "@leofcoin/utils": "^1.1.18",
     "@vandeurenglenn/easy-worker": "^1.0.2"

package/CHANGELOG.md

@@ -1,80 +0,0 @@
-# @leofcoin/workers
-
-## 1.5.0
-
-### Minor Changes
-
-- Update chain & machine-worker to support LIP1
-
-## 1.4.19
-
-### Patch Changes
-
-- 78299bf: bump
-- Updated dependencies [78299bf]
-  - @leofcoin/addresses@1.0.23
-  - @leofcoin/lib@1.2.43
-  - @leofcoin/messages@1.4.13
-  - @leofcoin/utils@1.1.18
-
-## 1.4.18
-
-### Patch Changes
-
-- Fix browser build
-
-## 1.4.17
-
-### Patch Changes
-
-- Upgrade dependencies
-- Updated dependencies
-  - @leofcoin/addresses@1.0.22
-  - @leofcoin/lib@1.2.42
-  - @leofcoin/messages@1.4.12
-  - @leofcoin/utils@1.1.17
-
-## 1.4.16
-
-### Patch Changes
-
-- Upgrade dependencies
-- Updated dependencies
-  - @leofcoin/addresses@1.0.21
-  - @leofcoin/messages@1.4.11
-  - @leofcoin/utils@1.1.16
-  - @leofcoin/lib@1.2.41
-
-## 1.4.15
-
-### Patch Changes
-
-- fb4e9c7: Bump
-- Updated dependencies [fb4e9c7]
-- Updated dependencies [1da023a]
-  - @leofcoin/addresses@1.0.20
-  - @leofcoin/messages@1.4.10
-  - @leofcoin/utils@1.1.15
-  - @leofcoin/lib@1.2.40
-
-## 1.4.14
-
-### Patch Changes
-
-- d239d6b: Bump
-- d239d6b: set to public
-- Updated dependencies [d239d6b]
-- Updated dependencies [d239d6b]
-  - @leofcoin/addresses@1.0.19
-  - @leofcoin/lib@1.2.39
-  - @leofcoin/messages@1.4.9
-  - @leofcoin/utils@1.1.14
-
-## 1.4.13
-
-### Patch Changes
-
-- c24054d: State it
-- Updated dependencies [c24054d]
-  - @leofcoin/addresses@1.0.18
-  - @leofcoin/lib@1.2.38

package/src/chain-worker.ts

@@ -1,42 +0,0 @@
-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/log-worker.ts

@@ -1,50 +0,0 @@
-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,417 +0,0 @@
-import { BlockMessage, ContractMessage, TransactionMessage } from '@leofcoin/messages'
-import { formatBytes, BigNumber } from '@leofcoin/utils'
-import addresses from '@leofcoin/addresses'
-import bytecodes from '@leofcoin/lib/bytecodes' assert { type: 'json' }
-import EasyWorker from '@vandeurenglenn/easy-worker'
-import { nativeToken } from '@leofcoin/addresses'
-import LittlePubSub from '@vandeurenglenn/little-pubsub'
-const pubsub = new LittlePubSub()
-const worker = new EasyWorker()
-
-const contractFactoryMessage = bytecodes.contractFactory
-const nativeTokenMessage = bytecodes.nativeToken
-const nameServiceMessage = bytecodes.nameService
-const validatorsMessage = bytecodes.validators
-
-const latestTransactions = []
-let nativeCalls = 0
-let nativeBurns = 0
-let nativeMints = 0
-let nativeTransfers = 0
-let totalTransactions = 0
-
-let totalBurnAmount = 0
-let totalMintAmount = 0
-let totalTransferAmount = 0
-
-let blocks = []
-let contracts = {}
-const _ = {}
-
-globalThis.BigNumber = BigNumber
-
-let lastBlock = { index: -1, hash: '0x0', previousHash: '0x0' }
-
-const debug = (message) => {
-  worker.postMessage({
-    type: 'debug',
-    message
-  })
-}
-
-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 respond = (id, value) => {
-  worker.postMessage({
-    type: 'response',
-    value,
-    id
-  })
-}
-
-_.runContract = async ({ decoded, hash, encoded }, state) => {
-  const params = decoded.constructorParameters
-  try {
-    const func = new Function(new TextDecoder().decode(decoded.contract))
-    const Contract = func()
-
-    if (state) params.push(state)
-
-    globalThis.msg = createMessage(decoded.creator, hash)
-    contracts[hash] = await new Contract(...params)
-
-    debug(`loaded contract: ${hash} size: ${formatBytes(encoded.length)}`)
-  } catch (e) {
-    console.log(e)
-    worker.postMessage({
-      type: 'contractError',
-      message: e.message,
-      hash
-    })
-  }
-}
-
-_.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) {
-    console.log({ e })
-    throw new Error(
-      `error: ${e.message}
-      contract: ${contract}
-      method: ${method}
-      params: ${JSON.stringify(params, null, '\t')}
-      `
-    )
-  }
-}
-
-const createMessage = (sender = globalThis.peerid, contract) => {
-  return {
-    contract,
-    sender,
-    call: _.execute,
-    staticCall: get
-  }
-}
-
-const _executeTransaction = async (transaction) => {
-  const hash = await new TransactionMessage(transaction).hash()
-  if (latestTransactions.includes(hash)) {
-    throw new Error(`double transaction found: ${hash} in block ${block.index}`)
-  } else {
-    latestTransactions.push(hash)
-    const { from, to, method, params, nonce } = transaction
-    globalThis.msg = createMessage(from)
-
-    await _.execute({ contract: to, method, params })
-    if (to === nativeToken) {
-      nativeCalls += 1
-      if (method === 'burn') {
-        nativeBurns += 1
-        totalBurnAmount += params[0]
-      }
-      if (method === 'mint') {
-        nativeMints += 1
-        totalMintAmount += params[0]
-      }
-      if (method === 'transfer') {
-        nativeTransfers += 1
-        totalTransferAmount += params[0]
-      }
-    }
-    totalTransactions += 1
-
-    worker.postMessage({
-      type: 'transactionLoaded',
-      result: {
-        hash,
-        from,
-        nonce: String(nonce)
-      }
-    })
-  }
-}
-
-const addToWantList = (hash) => {
-  worker.postMessage({
-    type: 'addToWantList',
-    hash
-  })
-}
-
-_.init = async (message) => {
-  let { peerid, fromState, state, info } = message
-  globalThis.peerid = peerid
-  console.log({ fromState })
-  if (fromState) {
-    nativeCalls = info.nativeCalls
-    nativeBurns = info.nativeBurns
-    nativeMints = info.nativeMints
-    nativeTransfers = info.nativeTransfers
-    totalTransactions = info.totalTransactions
-    totalBurnAmount = info.totalBurnAmount
-    totalMintAmount = info.totalMintAmount
-    totalTransferAmount = info.totalTransferAmount
-
-    lastBlock = message.lastBlock
-    const setState = async (address, state) => {
-      const contractBytes = await resolveContract(address)
-      if (contractBytes === address) {
-        addToWantList(address)
-        return
-      }
-      const contract = await new ContractMessage(contractBytes)
-
-      await _.runContract({ hash: address, decoded: contract.decoded, encoded: contract.encoded }, state)
-    }
-
-    const entries = Object.entries(state)
-    if (entries.length > 0) {
-      const promises = []
-      for (const [address, value] of entries) {
-        promises.push(setState(address, value))
-      }
-      await Promise.all(promises)
-    }
-
-    const promises = []
-    if (!contracts[addresses.contractFactory]) promises.push(setState(addresses.contractFactory))
-    if (!contracts[addresses.nameService]) promises.push(setState(addresses.nameService))
-    if (!contracts[addresses.validators]) promises.push(setState(addresses.validators))
-    if (!contracts[addresses.nativeToken]) promises.push(setState(addresses.nativeToken))
-    // 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
-    //   })
-    // )
-    await Promise.all(promises)
-  } else {
-    await Promise.all(
-      [contractFactoryMessage, nativeTokenMessage, nameServiceMessage, validatorsMessage].map(async (contract) => {
-        contract = await new ContractMessage(new Uint8Array(contract.split(',')))
-        return _.runContract({ decoded: contract.decoded, encoded: contract.encoded, hash: await contract.hash() })
-      })
-    )
-    console.log({ blocks: message.blocks })
-    if (message.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 = './'
-      // }
-
-      // let _worker = await new EasyWorker(pre + '@leofcoin/workers/block-worker.js', {
-      //   serialization: 'advanced',
-      //   type: 'module'
-      // })
-      // blocks = await _worker.once(message.blocks)
-      // _worker = null
-      // blocks = unique(globalThis.blocks ? globalThis : [], blocks)
-      // for (let i = 0; i < blocks.length; i++) {
-
-      // }
-      blocks = message.blocks
-      for (const block of blocks) {
-        // we only revalidate the latest 24 blocks
-        // every 24 blocks a snapshot is taken and stored in state
-        // this means contracts will be restored from this state
-        // this also means devs NEED to make sure the state can be restored
-        // on contract deploy an error will be thrown if state wasn't recoverable
-        if (block.index >= blocks.length - 24) {
-          const transactionCount = blocks[block.index].transactions.length
-          latestTransactions.splice(-transactionCount, latestTransactions.length)
-        }
-        if (!block.loaded && !fromState) {
-          try {
-            const transactions = await Promise.all(
-              block.transactions.map(async (transaction) => {
-                const message = new TransactionMessage(await resolveTransaction(transaction)).decode()
-                if (message === transaction) {
-                  throw new Error(`nothing found for ${transaction}`)
-                }
-              })
-            )
-            const priority = transactions
-              .filter((transaction) => transaction.priority)
-              ?.sort((a, b) => a.nonce - b.nonce)
-            if (priority.length > 0)
-              for (const transaction of priority) {
-                await _executeTransaction(transaction)
-              }
-
-            await Promise.all(
-              transactions
-                .filter((transaction) => !transaction.priority)
-                .map(async (transaction) => _executeTransaction(transaction))
-            )
-            block.loaded = true
-            worker.postMessage({
-              type: 'debug',
-              message: `loaded transactions for block: ${block.hash} @${block.index}`
-            })
-          } catch (error) {
-            // just tell chain it's ready so we can get this node sync
-            // when a node connects this node will try to resolve the wantList
-            // this should result in the node beeing sync
-            if (error.message.includes('nothing found for')) worker.postMessage({ type: 'machine-ready', lastBlock })
-            else console.error(error)
-          }
-        }
-      }
-      if (blocks.length > 0) {
-        lastBlock = blocks[blocks.length - 1]
-      }
-      globalThis.blocks = blocks
-    }
-  }
-
-  worker.postMessage({ type: 'machine-ready', lastBlock })
-}
-
-_.addLoadedBlock = (block) => {
-  blocks[block.index - 1] = block
-  lastBlock = blocks[blocks.length - 1]
-  return true
-}
-
-_.loadBlock = (block) => {
-  // todo validate here and deprecate addLoadedBlock
-}
-
-const askFor = (question, input) =>
-  new Promise((resolve) => {
-    const id = globalThis.crypto.randomUUID()
-    pubsub.subscribe(id, resolve)
-    worker.postMessage({
-      type: 'ask',
-      question,
-      input,
-      id
-    })
-  })
-
-const resolveContract = (hash) => askFor('contract', hash)
-
-const resolveTransaction = (hash) => askFor('transaction', hash)
-
-const runTask = async (id, taskName, input) => {
-  try {
-    const result = await _[taskName](input)
-    respond(id, result)
-  } catch (e) {
-    worker.postMessage({
-      type: `${taskName}Error`,
-      message: e.message,
-      id
-    })
-  }
-}
-
-worker.onmessage(({ id, type, input }) => {
-  if (pubsub.hasSubscribers(id)) {
-    pubsub.publish(id, input)
-    return
-  }
-  switch (type) {
-    case 'init':
-      runTask(id, 'init', input)
-      break
-    case 'run':
-      runTask(id, 'runContract', input)
-      break
-    case 'execute':
-      runTask(id, 'execute', input)
-      break
-    case 'addLoadedBlock':
-      runTask(id, 'addLoadedBlock', input)
-      break
-    case 'nativeCalls':
-      respond(id, nativeCalls)
-      break
-    case 'contracts':
-      respond(id, contracts)
-      break
-    case 'nativeMints':
-      respond(id, nativeMints)
-      break
-    case 'nativeBurns':
-      respond(id, nativeBurns)
-      break
-    case 'nativeTransfers':
-      respond(id, nativeTransfers)
-      break
-    case 'totalBurnAmount':
-      respond(id, totalBurnAmount)
-      break
-    case 'totalMintAmount':
-      respond(id, totalMintAmount)
-      break
-    case 'totalTransferAmount':
-      respond(id, totalTransferAmount)
-      break
-    case 'totalTransfers':
-      respond(id, totalTransfers)
-      break
-    case 'totalBlocks':
-      respond(id, blocks.length)
-      break
-    case 'blocks':
-      respond(id, input ? blocks.slice(input.from, input.to) : blocks)
-      break
-    case 'block':
-      respond(id, blocks[input - 1])
-      break
-    case 'lastBlock':
-      respond(id, lastBlock)
-      break
-    case 'latestTransactions':
-      respond(id, latestTransactions)
-      break
-    case 'totalTransactions':
-      respond(id, totalTransactions)
-      break
-    case 'has':
-      respond(id, has(input.address))
-      break
-    case 'get':
-      respond(id, get(input))
-      break
-    default:
-      console.log(`machine-worker: unsupported taskType: ${type}`)
-      break
-  }
-})

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "NodeNext",
-    "target": "ES2022",
-    "outDir": "./exports",
-    "moduleResolution": "NodeNext",
-    "declaration": true,
-    "emitDeclarationOnly": true,
-    "declarationDir": "./exports",
-    "allowSyntheticDefaultImports": true,
-    "resolveJsonModule": true,
-    "allowJs": true,
-    "useDefineForClassFields": false,
-    "types": ["node"]
-  },
-  "include": ["./src/**/*"],
-  "exclude": ["node_modules"]
-}