@leofcoin/workers 1.0.0

package/dist/module/utils-96ad7b3e.js

@@ -0,0 +1,301 @@
+import _BN from 'bn.js';
+import { isBytes, hexlify, isHexString } from '@ethersproject/bytes';
+import { Logger } from '@ethersproject/logger';
+import '@ethersproject/bignumber';
+
+const version$1 = "bignumber/5.6.2";
+
+var BN = _BN.BN;
+const logger = new Logger(version$1);
+const _constructorGuard = {};
+const MAX_SAFE = 0x1fffffffffffff;
+// Only warn about passing 10 into radix once
+let _warnedToStringRadix = false;
+class BigNumber {
+    constructor(constructorGuard, hex) {
+        if (constructorGuard !== _constructorGuard) {
+            logger.throwError("cannot call constructor directly; use BigNumber.from", Logger.errors.UNSUPPORTED_OPERATION, {
+                operation: "new (BigNumber)"
+            });
+        }
+        this._hex = hex;
+        this._isBigNumber = true;
+        Object.freeze(this);
+    }
+    fromTwos(value) {
+        return toBigNumber(toBN(this).fromTwos(value));
+    }
+    toTwos(value) {
+        return toBigNumber(toBN(this).toTwos(value));
+    }
+    abs() {
+        if (this._hex[0] === "-") {
+            return BigNumber.from(this._hex.substring(1));
+        }
+        return this;
+    }
+    add(other) {
+        return toBigNumber(toBN(this).add(toBN(other)));
+    }
+    sub(other) {
+        return toBigNumber(toBN(this).sub(toBN(other)));
+    }
+    div(other) {
+        const o = BigNumber.from(other);
+        if (o.isZero()) {
+            throwFault("division-by-zero", "div");
+        }
+        return toBigNumber(toBN(this).div(toBN(other)));
+    }
+    mul(other) {
+        return toBigNumber(toBN(this).mul(toBN(other)));
+    }
+    mod(other) {
+        const value = toBN(other);
+        if (value.isNeg()) {
+            throwFault("division-by-zero", "mod");
+        }
+        return toBigNumber(toBN(this).umod(value));
+    }
+    pow(other) {
+        const value = toBN(other);
+        if (value.isNeg()) {
+            throwFault("negative-power", "pow");
+        }
+        return toBigNumber(toBN(this).pow(value));
+    }
+    and(other) {
+        const value = toBN(other);
+        if (this.isNegative() || value.isNeg()) {
+            throwFault("unbound-bitwise-result", "and");
+        }
+        return toBigNumber(toBN(this).and(value));
+    }
+    or(other) {
+        const value = toBN(other);
+        if (this.isNegative() || value.isNeg()) {
+            throwFault("unbound-bitwise-result", "or");
+        }
+        return toBigNumber(toBN(this).or(value));
+    }
+    xor(other) {
+        const value = toBN(other);
+        if (this.isNegative() || value.isNeg()) {
+            throwFault("unbound-bitwise-result", "xor");
+        }
+        return toBigNumber(toBN(this).xor(value));
+    }
+    mask(value) {
+        if (this.isNegative() || value < 0) {
+            throwFault("negative-width", "mask");
+        }
+        return toBigNumber(toBN(this).maskn(value));
+    }
+    shl(value) {
+        if (this.isNegative() || value < 0) {
+            throwFault("negative-width", "shl");
+        }
+        return toBigNumber(toBN(this).shln(value));
+    }
+    shr(value) {
+        if (this.isNegative() || value < 0) {
+            throwFault("negative-width", "shr");
+        }
+        return toBigNumber(toBN(this).shrn(value));
+    }
+    eq(other) {
+        return toBN(this).eq(toBN(other));
+    }
+    lt(other) {
+        return toBN(this).lt(toBN(other));
+    }
+    lte(other) {
+        return toBN(this).lte(toBN(other));
+    }
+    gt(other) {
+        return toBN(this).gt(toBN(other));
+    }
+    gte(other) {
+        return toBN(this).gte(toBN(other));
+    }
+    isNegative() {
+        return (this._hex[0] === "-");
+    }
+    isZero() {
+        return toBN(this).isZero();
+    }
+    toNumber() {
+        try {
+            return toBN(this).toNumber();
+        }
+        catch (error) {
+            throwFault("overflow", "toNumber", this.toString());
+        }
+        return null;
+    }
+    toBigInt() {
+        try {
+            return BigInt(this.toString());
+        }
+        catch (e) { }
+        return logger.throwError("this platform does not support BigInt", Logger.errors.UNSUPPORTED_OPERATION, {
+            value: this.toString()
+        });
+    }
+    toString() {
+        // Lots of people expect this, which we do not support, so check (See: #889)
+        if (arguments.length > 0) {
+            if (arguments[0] === 10) {
+                if (!_warnedToStringRadix) {
+                    _warnedToStringRadix = true;
+                    logger.warn("BigNumber.toString does not accept any parameters; base-10 is assumed");
+                }
+            }
+            else if (arguments[0] === 16) {
+                logger.throwError("BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", Logger.errors.UNEXPECTED_ARGUMENT, {});
+            }
+            else {
+                logger.throwError("BigNumber.toString does not accept parameters", Logger.errors.UNEXPECTED_ARGUMENT, {});
+            }
+        }
+        return toBN(this).toString(10);
+    }
+    toHexString() {
+        return this._hex;
+    }
+    toJSON(key) {
+        return { type: "BigNumber", hex: this.toHexString() };
+    }
+    static from(value) {
+        if (value instanceof BigNumber) {
+            return value;
+        }
+        if (typeof (value) === "string") {
+            if (value.match(/^-?0x[0-9a-f]+$/i)) {
+                return new BigNumber(_constructorGuard, toHex(value));
+            }
+            if (value.match(/^-?[0-9]+$/)) {
+                return new BigNumber(_constructorGuard, toHex(new BN(value)));
+            }
+            return logger.throwArgumentError("invalid BigNumber string", "value", value);
+        }
+        if (typeof (value) === "number") {
+            if (value % 1) {
+                throwFault("underflow", "BigNumber.from", value);
+            }
+            if (value >= MAX_SAFE || value <= -MAX_SAFE) {
+                throwFault("overflow", "BigNumber.from", value);
+            }
+            return BigNumber.from(String(value));
+        }
+        const anyValue = value;
+        if (typeof (anyValue) === "bigint") {
+            return BigNumber.from(anyValue.toString());
+        }
+        if (isBytes(anyValue)) {
+            return BigNumber.from(hexlify(anyValue));
+        }
+        if (anyValue) {
+            // Hexable interface (takes priority)
+            if (anyValue.toHexString) {
+                const hex = anyValue.toHexString();
+                if (typeof (hex) === "string") {
+                    return BigNumber.from(hex);
+                }
+            }
+            else {
+                // For now, handle legacy JSON-ified values (goes away in v6)
+                let hex = anyValue._hex;
+                // New-form JSON
+                if (hex == null && anyValue.type === "BigNumber") {
+                    hex = anyValue.hex;
+                }
+                if (typeof (hex) === "string") {
+                    if (isHexString(hex) || (hex[0] === "-" && isHexString(hex.substring(1)))) {
+                        return BigNumber.from(hex);
+                    }
+                }
+            }
+        }
+        return logger.throwArgumentError("invalid BigNumber value", "value", value);
+    }
+    static isBigNumber(value) {
+        return !!(value && value._isBigNumber);
+    }
+}
+// Normalize the hex string
+function toHex(value) {
+    // For BN, call on the hex string
+    if (typeof (value) !== "string") {
+        return toHex(value.toString(16));
+    }
+    // If negative, prepend the negative sign to the normalized positive value
+    if (value[0] === "-") {
+        // Strip off the negative sign
+        value = value.substring(1);
+        // Cannot have multiple negative signs (e.g. "--0x04")
+        if (value[0] === "-") {
+            logger.throwArgumentError("invalid hex", "value", value);
+        }
+        // Call toHex on the positive component
+        value = toHex(value);
+        // Do not allow "-0x00"
+        if (value === "0x00") {
+            return value;
+        }
+        // Negate the value
+        return "-" + value;
+    }
+    // Add a "0x" prefix if missing
+    if (value.substring(0, 2) !== "0x") {
+        value = "0x" + value;
+    }
+    // Normalize zero
+    if (value === "0x") {
+        return "0x00";
+    }
+    // Make the string even length
+    if (value.length % 2) {
+        value = "0x0" + value.substring(2);
+    }
+    // Trim to smallest even-length string
+    while (value.length > 4 && value.substring(0, 4) === "0x00") {
+        value = "0x" + value.substring(4);
+    }
+    return value;
+}
+function toBigNumber(value) {
+    return BigNumber.from(toHex(value));
+}
+function toBN(value) {
+    const hex = BigNumber.from(value).toHexString();
+    if (hex[0] === "-") {
+        return (new BN("-" + hex.substring(3), 16));
+    }
+    return new BN(hex.substring(2), 16);
+}
+function throwFault(fault, operation, value) {
+    const params = { fault: fault, operation: operation };
+    if (value != null) {
+        params.value = value;
+    }
+    return logger.throwError(fault, Logger.errors.NUMERIC_FAULT, params);
+}
+
+const version = "units/5.6.1";
+
+new Logger(version);
+
+const byteFormats = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+
+const formatBytes = (bytes, decimals = 2) => {
+  if (bytes === 0) return '0 Bytes';
+  if (decimals < 0) decimals = 0;
+
+  const k = 1024;
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${byteFormats[i]}`
+};
+
+export { BigNumber as B, formatBytes as f };

package/dist/module/workers.js

@@ -0,0 +1,19 @@
+import { t as transactionWorker } from './transaction-worker-0f96397e.js';
+import { b as blockWorker } from './block-worker-f5b28240.js';
+import { p as poolWorker } from './pool-worker-8d3369b4.js';
+import { m as machineWorker } from './machine-worker-8054fa84.js';
+import '@leofcoin/codec-format-interface';
+import './transaction-d06dc6c4.js';
+import './utils-96ad7b3e.js';
+import 'bn.js';
+import '@ethersproject/bytes';
+import '@ethersproject/logger';
+import '@ethersproject/bignumber';
+import 'child_process';
+
+const TransactionWorker = transactionWorker;
+const BlockWorker = blockWorker;
+const PoolWorker = poolWorker;
+const MachineWorker = machineWorker;
+
+export { BlockWorker, MachineWorker, PoolWorker, TransactionWorker };

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@leofcoin/workers",
+  "version": "1.0.0",
+  "description": "",
+  "module": "src/workers.js",
+  "scripts": {
+    "build": "rollup -c",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^22.0.2",
+    "@rollup/plugin-json": "^4.1.0",
+    "@rollup/plugin-node-resolve": "^14.1.0",
+    "rollup": "^2.79.1"
+  },
+  "dependencies": {
+    "@leofcoin/messages": "^1.2.0"
+  }
+}

package/rollup.config.js

@@ -0,0 +1,40 @@
+import { execSync } from 'child_process'
+import json from '@rollup/plugin-json'
+import resolve from '@rollup/plugin-node-resolve'
+
+import commonjs from '@rollup/plugin-commonjs'
+try {
+  execSync(`rm -rf ./dist/**`)
+
+} catch (e) {
+
+}
+export default [{
+  input: ['./src/workers.js', './src/transaction-worker.js', './src/block-worker.js', './src/pool-worker.js', './src/machine-worker.js'],
+  
+  plugins: [
+    json()
+  ],
+  output: [{
+    dir: './dist/commonjs',
+    format: 'cjs'
+  }, {    
+    dir: './dist/module',
+    format: 'es'
+  }]
+}, {
+  input: ['./src/workers.js', './src/transaction-worker.js', './src/block-worker.js', './src/pool-worker.js', './src/machine-worker.js'],
+  
+  plugins: [
+    json(),
+    commonjs(),
+    resolve()
+  ],
+  output: [{
+    dir: './dist/bundle/commonjs',
+    format: 'cjs'
+  }, {    
+    dir: './dist/bundle/module',
+    format: 'es'
+  }]
+}]

package/src/block-worker.js

@@ -0,0 +1,71 @@
+import { BlockMessage } from '../../messages/src/messages'
+import { formatBytes, BigNumber } from '../../utils/src/utils'
+import bytecodes  from '../../lib/src/bytecodes.json'
+import { fork } from 'child_process'
+
+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 run = async (blocks) => {  
+  blocks = await Promise.all(blocks.map(block => new BlockMessage(block)))
+  blocks = blocks.sort((a, b) => a.decoded.timestamp - b.decoded.timestamp)
+
+  blocks = await Promise.all(blocks.map(block => new Promise(async (resolve, reject) => {
+    if (globalThis.process) {
+      const worker = fork('./workers/transaction-worker.js', {serialization: 'advanced'})
+    
+      worker.once('message', async transactions => {
+        block.decoded.transactions = transactions
+        const size = block.encoded.length || block.encoded.byteLength
+        console.log(`loaded block: ${await block.hash} @${block.decoded.index} ${formatBytes(size)}`);
+        resolve(block)
+      })
+      
+      worker.send(block.decoded.transactions)
+    } else {
+      const worker = new Worker('./workers/transaction-worker.js')
+      worker.onmessage = async message => {
+        const transactions = message.data
+        block.decoded.transactions = transactions
+        const size = block.encoded.length || block.encoded.byteLength
+        console.log(`loaded block: ${await block.hash} @${block.decoded.index} ${formatBytes(size)}`);
+        resolve(block)
+      }
+      worker.postMessage(block.decoded.transactions)
+    }    
+  })))
+  return blocks
+}
+
+const tasks = async blocks => {
+  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'
+    }
+  }  
+  
+  blocks = await run(blocks)
+  globalThis.process ? process.send(blocks) : postMessage(blocks)
+}
+ 
+if (globalThis.process) {
+  process.on('message', tasks)
+} else {
+  onmessage = message => tasks(message.data)
+}

package/src/machine-worker.js

@@ -0,0 +1,160 @@
+import { BlockMessage, ContractMessage, TransactionMessage } from './../../messages/src/messages'
+import { formatBytes, BigNumber } from './../../utils/src/utils'
+import bytecodes  from './../../lib/src/bytecodes.json'
+import { fork } from 'child_process'
+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 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 (contractMessage) => {
+  const params = contractMessage.decoded.constructorParameters
+  try {
+
+    const func = new Function(contractMessage.decoded.contract)
+    const Contract = func()
+
+    globalThis.msg = createMessage(contractMessage.decoded.creator)
+    // globalThis.msg = {sender: contractMessage.decoded.creator}
+    contracts[await contractMessage.hash] = await new Contract(...params)
+    process.send({
+      type: 'debug',
+      messages: [
+        `loaded contract: ${await contractMessage.hash}`,
+        `size: ${formatBytes(contractMessage.encoded.length)}`
+      ]
+    })
+  } catch (e) {
+    console.log(e);
+    process.send({
+      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.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(contract)
+    return contract
+  }))
+
+  const worker = fork('./workers/block-worker.js', {serialization: 'advanced'})
+  // worker.on('message')
+    worker.once('message', async (blocks) => {
+      for (const block of blocks) {
+        await Promise.all(block.decoded.transactions.map(async message => {
+          const {from, to, method, params} = message.decoded
+          globalThis.msg = createMessage(from)
+        
+          await execute(to, method, params)
+        }))
+      }
+      process.send({type: 'machine-ready'})
+      worker.kill() 
+        
+
+      
+    })
+    worker.send(blocks)
+}
+
+const tasks = async (e) => {
+  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'
+    }
+  }
+    if (e.type === 'init') await _init(e.input)
+    if (e.type === 'get') {
+      const value = await get(e.input.contract, e.input.method, e.input.params)
+      process.send({
+        type: 'response',
+        id: e.id,
+        value
+      })
+    }
+    if (e.type === 'execute') {
+      try {
+        const value = await execute(e.input.contract, e.input.method, e.input.params)
+        process.send({
+          type: 'response',
+          id: e.id,
+          value
+        })
+      } catch(e) {
+        process.send({
+          type: 'executionError',
+          message: e,
+          id: e.id
+          
+        })
+      }
+    }
+  }
+
+
+if (globalThis.process) {
+  process.on('message', tasks)
+} else {
+  onmessage = message => tasks(message.data)
+}

package/src/pool-worker.js

@@ -0,0 +1,37 @@
+import { TransactionMessage } from '../../messages/src/messages'
+
+globalThis.peernet = globalThis.peernet || {}
+globalThis.contracts = {}
+
+const tasks = async transactions => {
+  
+  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'
+    }
+  }
+  
+  transactions = await Promise.all(transactions.map(async message => {
+    message = await new TransactionMessage(message)
+    
+    return {...message.decoded, hash: await message.hash, size: message.encoded.length}
+  }))
+
+  globalThis.process ? process.send(transactions) : postMessage(transactions)
+  
+}
+
+if (globalThis.process) {
+  process.on('message', tasks)
+} else {
+  onmessage = message => tasks(message.data)
+}

package/src/transaction-worker.js

@@ -0,0 +1,26 @@
+import { TransactionMessage } from '../../messages/src/messages'
+
+globalThis.peernet = globalThis.peernet || {}
+globalThis.contracts = {}
+ 
+
+process.on('message', async (transactions) => {
+  
+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'
+  }
+}
+  transactions = await Promise.all(transactions.map(async message => new TransactionMessage(message)))
+
+  process.send(transactions)
+});

package/src/workers.js

@@ -0,0 +1,9 @@
+import * as transactionWorker from './transaction-worker'
+import * as blockWorker from './block-worker'
+import * as poolWorker from './pool-worker'
+import * as machineWorker from './machine-worker'
+
+export const TransactionWorker = transactionWorker
+export const BlockWorker = blockWorker
+export const PoolWorker = poolWorker
+export const MachineWorker = machineWorker