@leofcoin/chain 1.4.20 → 1.4.22

package/workers/machine-worker.js

@@ -1,219 +1,219 @@
-import { BlockMessage, ContractMessage } from './../../messages/src/messages.js'
-import { formatBytes, BigNumber } from './../../utils/src/utils.js'
-import bytecodes  from './../../lib/src/bytecodes.json' 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.peernet = globalThis.peernet || {}
-globalThis.contracts = {}
-
-const unique = arr => arr.filter((el, pos, arr) => {
-  return arr.indexOf(el) == pos;
-})
-
-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(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 e
-  }
-}
-
-
-const createMessage = (sender = globalThis.peerid) => {
-  return {
-    sender,
-    call: execute,
-    staticCall: get
-  }
-}
-
-const _init = async ({ contracts, blocks, peerid })=> {
-  
-  globalThis.peernet.codecs =  {
-    'contract-message': {
-      codec: parseInt('63636d', 16),
-      hashAlg: 'keccak-256'
-    },
-    'transaction-message': {
-      codec: parseInt('746d', 16),
-      hashAlg: 'keccak-256'
-    },
-    'block-message': {
-      codec: parseInt('626d', 16),
-      hashAlg: 'keccak-256'
-    }
-  }
-
-  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) {
-    const _worker = await new EasyWorker('./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].decoded;    
-      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 === '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
-          
-        })
-      }
-    }
-  }
-
+import { BlockMessage, ContractMessage } from './../../messages/src/messages.js'
+import { formatBytes, BigNumber } from './../../utils/src/utils.js'
+import bytecodes  from './../../lib/src/bytecodes.json' 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.peernet = globalThis.peernet || {}
+globalThis.contracts = {}
+
+const unique = arr => arr.filter((el, pos, arr) => {
+  return arr.indexOf(el) == pos;
+})
+
+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(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 e
+  }
+}
+
+
+const createMessage = (sender = globalThis.peerid) => {
+  return {
+    sender,
+    call: execute,
+    staticCall: get
+  }
+}
+
+const _init = async ({ contracts, blocks, peerid })=> {
+  
+  globalThis.peernet.codecs =  {
+    'contract-message': {
+      codec: parseInt('63636d', 16),
+      hashAlg: 'keccak-256'
+    },
+    'transaction-message': {
+      codec: parseInt('746d', 16),
+      hashAlg: 'keccak-256'
+    },
+    'block-message': {
+      codec: parseInt('626d', 16),
+      hashAlg: 'keccak-256'
+    }
+  }
+
+  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) {
+    const _worker = await new EasyWorker('./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].decoded;    
+      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 === '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/workers/pool-worker.js

@@ -1,28 +1,28 @@
-import { TransactionMessage } from './../../messages/src/messages.js'
-
-import EasyWorker from '@vandeurenglenn/easy-worker'
-
-globalThis.peernet = globalThis.peernet || {}
-globalThis.contracts = {}
-
-const worker = new EasyWorker()
-
-const tasks = async transactions => {
-  
-  globalThis.peernet.codecs =  {
-    'transaction-message': {
-      codec: parseInt('746d', 16),
-      hashAlg: 'keccak-256'
-    }
-  }
-  
-  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 './../../messages/src/messages.js'
+
+import EasyWorker from '@vandeurenglenn/easy-worker'
+
+globalThis.peernet = globalThis.peernet || {}
+globalThis.contracts = {}
+
+const worker = new EasyWorker()
+
+const tasks = async transactions => {
+  
+  globalThis.peernet.codecs =  {
+    'transaction-message': {
+      codec: parseInt('746d', 16),
+      hashAlg: 'keccak-256'
+    }
+  }
+  
+  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/workers/transaction-worker.js

@@ -1,20 +1,20 @@
-import { TransactionMessage } from './../../messages/src/messages.js'
-
-globalThis.peernet = globalThis.peernet || {}
-globalThis.contracts = {}
-
-import EasyWorker from '@vandeurenglenn/easy-worker'
-
-const worker = new EasyWorker()
-
-worker.onmessage(async (transactions) => {  
-  globalThis.peernet.codecs =  {
-    'transaction-message': {
-      codec: parseInt('746d', 16),
-      hashAlg: 'keccak-256'
-    }
-  }
-  transactions = await Promise.all(transactions.map(async message => new TransactionMessage(message)))
-
-  worker.postMessage(transactions)
+import { TransactionMessage } from './../../messages/src/messages.js'
+
+globalThis.peernet = globalThis.peernet || {}
+globalThis.contracts = {}
+
+import EasyWorker from '@vandeurenglenn/easy-worker'
+
+const worker = new EasyWorker()
+
+worker.onmessage(async (transactions) => {  
+  globalThis.peernet.codecs =  {
+    'transaction-message': {
+      codec: parseInt('746d', 16),
+      hashAlg: 'keccak-256'
+    }
+  }
+  transactions = await Promise.all(transactions.map(async message => new TransactionMessage(message)))
+
+  worker.postMessage(transactions)
 })

package/workers/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
+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

package/block-worker.js

@@ -1 +0,0 @@
-"use strict";var e=require("@leofcoin/codec-format-interface"),r=require("@ethersproject/bignumber");function s(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}require("@ethersproject/units"),require("randombytes");var a=s(require("@vandeurenglenn/easy-worker"));class BlockMessage extends e.FormatInterface{get keys(){return["index","previousHash","timestamp","reward","fees","transactions","validators"]}get messageName(){return"BlockMessage"}constructor(e){super(e,"\nmessage ValidatorMessage {\n  required string address = 1;\n  required string reward = 2;\n}\n\nmessage Transaction {\n  required string hash = 1;\n  required uint64 timestamp = 2;\n  required string from = 3;\n  required string to = 4;\n  required uint64 nonce = 5;\n  required string method = 6;\n  repeated string params = 7;\n}\n\nmessage BlockMessage {\n  required uint64 index = 1;\n  required string previousHash = 3;\n  required uint64 timestamp = 4;\n  required uint64 reward = 5;\n  required string fees = 6;\n  repeated Transaction transactions = 7;\n  repeated ValidatorMessage validators = 8;\n}\n",{name:"block-message"})}}const n=["Bytes","KB","MB","GB","TB","PB","EB","ZB","YB"],t=new a.default;globalThis.BigNumber=r.BigNumber,globalThis.peernet=globalThis.peernet||{},globalThis.contracts={};const i=async e=>(e=(e=await Promise.all(e.map((e=>new BlockMessage(e))))).sort(((e,r)=>e.decoded.timestamp-r.decoded.timestamp)),e=await Promise.all(e.map((e=>new Promise((async(r,s)=>{const a=e.encoded.length||e.encoded.byteLength;console.log(`loaded block: ${await e.hash} @${e.decoded.index} ${((e,r=2)=>{if(0===e)return"0 Bytes";r<0&&(r=0);const s=Math.floor(Math.log(e)/Math.log(1024));return`${parseFloat((e/Math.pow(1024,s)).toFixed(r))} ${n[s]}`})(a)}`),r(e)}))))));t.onmessage((e=>(async e=>{globalThis.peernet.codecs={"block-message":{codec:parseInt("626d",16),hashAlg:"keccak-256"}},e=await i(e),t.postMessage(e)})(e)));

package/demo/865.browser.js

@@ -1,10 +0,0 @@
-(self["webpackChunk_leofcoin_chain"] = self["webpackChunk_leofcoin_chain"] || []).push([[865],{
-
-/***/ 3865:
-/***/ (function() {
-
-/* (ignored) */
-
-/***/ })
-
-}])