@leofcoin/workers 1.4.12 → 1.4.14

package/CHANGELOG.md

@@ -0,0 +1,23 @@
+# @leofcoin/workers
+
+## 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/package.json

@@ -1,27 +1,29 @@
-{
-  "name": "@leofcoin/workers",
-  "version": "1.4.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": {
-    "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"
-  }
-}
+{
+  "name": "@leofcoin/workers",
+  "version": "1.4.14",
+  "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",
+    "./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/addresses": "^1.0.19",
+    "@leofcoin/lib": "^1.2.39",
+    "@leofcoin/messages": "^1.4.9",
+    "@leofcoin/storage": "^3.3.2",
+    "@leofcoin/utils": "^1.1.14",
+    "@vandeurenglenn/easy-worker": "^1.0.2"
+  }
+}

package/src/machine-worker.js

@@ -1,8 +1,12 @@
 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 { randomUUID } from 'crypto'
+import LittlePubSub from '@vandeurenglenn/little-pubsub'
+const pubsub = new LittlePubSub()
 const worker = new EasyWorker()
 
 const contractFactoryMessage = bytecodes.contractFactory
@@ -11,7 +15,6 @@ const nameServiceMessage = bytecodes.nameService
 const validatorsMessage = bytecodes.validators
 
 const latestTransactions = []
-
 let nativeCalls = 0
 let nativeBurns = 0
 let nativeMints = 0
@@ -30,6 +33,13 @@ 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
@@ -49,18 +59,28 @@ const get = ({ contract, method, params }) => {
   return result
 }
 
-_.runContract = async ({ decoded, hash, encoded }) => {
+const resolveContract = (address) => askFor('contract', address)
+
+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()
 
-    globalThis.msg = createMessage(decoded.creator)
+    if (state) params.push(state)
+
+    globalThis.msg = createMessage(decoded.creator, hash)
     contracts[hash] = await new Contract(...params)
-    worker.postMessage({
-      type: 'debug',
-      message: `loaded contract: ${hash} size: ${formatBytes(encoded.length)}`
-    })
+
+    debug(`loaded contract: ${hash} size: ${formatBytes(encoded.length)}`)
   } catch (e) {
     console.log(e)
     worker.postMessage({
@@ -74,6 +94,7 @@ _.runContract = async ({ decoded, hash, encoded }) => {
 _.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)
@@ -83,6 +104,7 @@ _.execute = async ({ contract, method, params }) => {
     // state.put(result)
     return result
   } catch (e) {
+    console.log({ e })
     throw new Error(
       `error: ${e.message}
       contract: ${contract}
@@ -93,8 +115,9 @@ _.execute = async ({ contract, method, params }) => {
   }
 }
 
-const createMessage = (sender = globalThis.peerid) => {
+const createMessage = (sender = globalThis.peerid, contract) => {
   return {
+    contract,
     sender,
     call: _.execute,
     staticCall: get
@@ -131,82 +154,108 @@ const _executeTransaction = async (transaction) => {
 }
 
 _.init = async (message) => {
-  let { contracts, peerid, fromState, states } = message
-  console.log({ states })
-
+  let { peerid, fromState, state } = message
   globalThis.peerid = peerid
+  console.log({ fromState })
   if (fromState) {
-  } else {
-    contracts = [contractFactoryMessage, nativeTokenMessage, nameServiceMessage, validatorsMessage]
+    lastBlock = message.lastBlock
+    const setState = async (address, state) => {
+      const contractBytes = await resolveContract(address)
+      const contract = await new ContractMessage(contractBytes)
 
-    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
-      })
-    )
-  }
-
-  if (message.blocks?.length > 0) {
-    let pre
+      await _.runContract({ hash: address, decoded: contract.decoded, encoded: contract.encoded }, state)
+    }
 
-    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 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)
     }
 
-    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++) {
-
-    // }
-    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 > 24) {
-        const transactionCount = blocks[block.index - 1].transactions.length
-        latestTransactions.splice(-(transactionCount - 1), latestTransactions.length)
+    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 = './'
       }
 
-      if (!block.loaded && !fromState) {
-        const priority = block.transactions.filter((transaction) => transaction.priority)
-        if (priority.length > 0)
+      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++) {
+
+      // }
+      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 > 24) {
+          const transactionCount = blocks[block.index - 1].transactions.length
+          latestTransactions.splice(-(transactionCount - 1), latestTransactions.length)
+        }
+
+        if (!block.loaded && !fromState) {
+          const priority = block.transactions.filter((transaction) => transaction.priority)
+          if (priority.length > 0)
+            await Promise.all(
+              priority.sort((a, b) => a.nonce - b.nonce).map((transaction) => _executeTransaction(transaction))
+            )
+
           await Promise.all(
-            priority.sort((a, b) => a.nonce - b.nonce).map((transaction) => _executeTransaction(transaction))
+            block.transactions
+              .filter((transaction) => !transaction.priority)
+              .map(async (transaction) => _executeTransaction(transaction))
           )
-
-        await Promise.all(
-          block.transactions
-            .filter((transaction) => !transaction.priority)
-            .map(async (transaction) => _executeTransaction(transaction))
-        )
+        }
+        block.loaded = true
+        worker.postMessage({
+          type: 'debug',
+          message: `loaded transactions for block: ${block.blockInfo.hash} @${block.blockInfo.index} ${formatBytes(
+            block.blockInfo.size
+          )}`
+        })
       }
-      block.loaded = true
-      worker.postMessage({
-        type: 'debug',
-        message: `loaded transactions for block: ${block.blockInfo.hash} @${block.blockInfo.index} ${formatBytes(
-          block.blockInfo.size
-        )}`
-      })
-    }
 
-    if (blocks.length > 0) {
-      lastBlock = blocks[blocks.length - 1]
+      if (blocks.length > 0) {
+        lastBlock = blocks[blocks.length - 1]
+      }
+      globalThis.blocks = blocks
     }
-    globalThis.blocks = blocks
   }
 
   worker.postMessage({ type: 'machine-ready', lastBlock })
@@ -216,6 +265,7 @@ _.init = async (message) => {
 
 _.addLoadedBlock = (block) => {
   blocks[block.index - 1] = block
+  lastBlock = blocks[blocks.length - 1]
   return true
 }
 
@@ -223,13 +273,17 @@ _.loadBlock = (block) => {
   // todo validate here and deprecate addLoadedBlock
 }
 
-const respond = (id, value) => {
-  worker.postMessage({
-    type: 'response',
-    value,
-    id
+const askFor = (question, input) =>
+  new Promise((resolve) => {
+    const id = randomUUID()
+    pubsub.subscribe(id, resolve)
+    worker.postMessage({
+      type: 'ask',
+      question,
+      input,
+      id
+    })
   })
-}
 
 const runTask = async (id, taskName, input) => {
   try {
@@ -245,6 +299,10 @@ const runTask = async (id, taskName, input) => {
 }
 
 worker.onmessage(({ id, type, input }) => {
+  if (pubsub.hasSubscribers(id)) {
+    pubsub.publish(id, input)
+    return
+  }
   switch (type) {
     case 'init':
       runTask(id, 'init', input)
@@ -286,7 +344,7 @@ worker.onmessage(({ id, type, input }) => {
       respond(id, blocks[input - 1])
       break
     case 'lastBlock':
-      respond(id, blocks[blocks.length - 1] || lastBlock)
+      respond(id, lastBlock)
       break
     case 'latestTransactions':
       respond(id, latestTransactions)

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "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"]
+}