@leofcoin/workers 1.4.8 → 1.4.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/workers",
-  "version": "1.4.8",
+  "version": "1.4.11",
   "description": "Workers used in @leofcoin/chain",
   "type": "module",
   "exports": {

package/src/block-worker.js

@@ -21,9 +21,6 @@ const run = async (blocks) => {
           const size = block.encoded.length || block.encoded.byteLength
           const hash = await block.hash()
           const index = block.decoded.index
-          console.log(`loaded block: ${hash} @${index} ${formatBytes(size)}`)
-          // todo we don't want this, need shared state
-          block.decoded.transactions = block.decoded.transactions.sort((a, b) => a.nonce - b.nonce)
           resolve({ ...block.decoded, hash, blockInfo: { hash, size, index } })
         })
     )

package/src/machine-worker.js

@@ -28,7 +28,7 @@ const _ = {}
 
 globalThis.BigNumber = BigNumber
 
-let lastBlock = { index: 0, hash: '0x0', previousHash: '0x0' }
+let lastBlock = { index: -1, hash: '0x0', previousHash: '0x0' }
 
 const unique = (arr) =>
   arr.filter((el, pos, arr) => {
@@ -101,6 +101,35 @@ const createMessage = (sender = globalThis.peerid) => {
   }
 }
 
+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
+      if (method === 'mint') nativeMints += 1
+      if (method === 'transfer') nativeTransfers += 1
+    }
+    totalTransactions += 1
+
+    worker.postMessage({
+      type: 'transactionLoaded',
+      result: {
+        hash,
+        from,
+        nonce: String(nonce)
+      }
+    })
+  }
+}
+
 _.init = async (message) => {
   let { contracts, peerid } = message
   globalThis.peerid = peerid
@@ -146,38 +175,20 @@ _.init = async (message) => {
         const transactionCount = blocks[block.index - 1].transactions.length
         latestTransactions.splice(-(transactionCount - 1), latestTransactions.length)
       }
-      await Promise.all(
-        block.transactions.map(async (transaction) => {
-          if (!block.loaded) {
-            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
-                if (method === 'mint') nativeMints += 1
-                if (method === 'transfer') nativeTransfers += 1
-              }
-              totalTransactions += 1
-
-              worker.postMessage({
-                type: 'transactionLoaded',
-                result: {
-                  hash,
-                  from,
-                  nonce: String(nonce)
-                }
-              })
-            }
-          }
-        })
-      )
+
+      if (!block.loaded) {
+        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(
+          block.transactions
+            .filter((transaction) => !transaction.priority)
+            .map(async (transaction) => _executeTransaction(transaction))
+        )
+      }
       block.loaded = true
       worker.postMessage({
         type: 'debug',
@@ -270,7 +281,7 @@ worker.onmessage(({ id, type, input }) => {
       respond(id, blocks[input - 1])
       break
     case 'lastBlock':
-      respond(id, blocks[blocks.length - 1])
+      respond(id, blocks[blocks.length - 1] || lastBlock)
       break
     case 'latestTransactions':
       respond(id, latestTransactions)