@leofcoin/workers 1.4.19 → 1.5.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @leofcoin/workers
 
+## 1.5.0
+
+### Minor Changes
+
+- Update chain & machine-worker to support LIP1
+
 ## 1.4.19
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/workers",
-  "version": "1.4.19",
+  "version": "1.5.1",
   "description": "Workers used in @leofcoin/chain",
   "type": "module",
   "private": false,

package/src/machine-worker.js

@@ -58,8 +58,6 @@ const get = ({ contract, method, params }) => {
   return result
 }
 
-const resolveContract = (address) => askFor('contract', address)
-
 const respond = (id, value) => {
   worker.postMessage({
     type: 'response',
@@ -161,6 +159,13 @@ const _executeTransaction = async (transaction) => {
   }
 }
 
+const addToWantList = (hash) => {
+  worker.postMessage({
+    type: 'addToWantList',
+    hash
+  })
+}
+
 _.init = async (message) => {
   let { peerid, fromState, state, info } = message
   globalThis.peerid = peerid
@@ -178,6 +183,10 @@ _.init = async (message) => {
     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)
@@ -214,60 +223,75 @@ _.init = async (message) => {
     )
     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 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
+      // 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 > 24) {
-          const transactionCount = blocks[block.index - 1].transactions.length
-          latestTransactions.splice(-(transactionCount - 1), latestTransactions.length)
+        if (block.index >= blocks.length - 24) {
+          const transactionCount = blocks[block.index].transactions.length
+          latestTransactions.splice(-transactionCount, 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))
+          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(
-            block.transactions
-              .filter((transaction) => !transaction.priority)
-              .map(async (transaction) => _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)
+          }
         }
-        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]
       }
@@ -276,8 +300,6 @@ _.init = async (message) => {
   }
 
   worker.postMessage({ type: 'machine-ready', lastBlock })
-
-  // worker.postMessage({blocks});
 }
 
 _.addLoadedBlock = (block) => {
@@ -302,6 +324,10 @@ const askFor = (question, input) =>
     })
   })
 
+const resolveContract = (hash) => askFor('contract', hash)
+
+const resolveTransaction = (hash) => askFor('transaction', hash)
+
 const runTask = async (id, taskName, input) => {
   try {
     const result = await _[taskName](input)