@leofcoin/chain 1.4.21 → 1.4.23

package/test/chain.js

@@ -1,150 +0,0 @@
-import { signTransaction } from '@leofcoin/lib'
-
-  globalThis.DEBUG = true
-  const Chain = await import('./../exports/chain.js');
-  const Node = await import('./../exports/node.js');
-  let imp = await import('../../networks/networks.js')
-  const networks = imp.default
-  console.log(networks.leofcoin.peach);
-  const node = await new Node.default({
-    network: 'leofcoin:peach',
-    networkName: 'leofcoin:peach',
-    networkVersion: 'peach',
-    stars: networks.leofcoin.peach.stars
-  })
-  const chain = await new Chain.default()
-  let start
-  // console.log(peernet.identity.sign());
-      await chain.participate(peernet.selectedAccount)
-      console.log(peernet.selectedAccount);
-const job = async () => {
-  
-  let nonce = await chain.getNonce(peernet.selectedAccount)
-  // // setTimeout(async () => {
-    let tx
-    // try {
-    //   const rawTransaction = await chain.createTransaction({
-    //     from: peernet.selectedAccount, 
-    //     to: chain.nativeToken, 
-    //     method: 'grantRole',
-    //     params: [peernet.selectedAccount, 'MINT']
-    //   })
-    //   const transaction = await signTransaction(rawTransaction, peernet.identity)
-    //   tx = await chain.sendTransaction(transaction)
-    //   console.log({tx});
-    //   await tx.wait
-
-    // } catch (e) {
-    //   console.log({e});
-    // }
-
-    // try {      
-    //   const rawTransaction = await chain.createTransaction({
-    //     from: peernet.selectedAccount, 
-    //     to: chain.nativeToken, 
-    //     method: 'mint',
-    //     params: [peernet.selectedAccount, chain.utils.parseUnits('100000000000000').toString()]
-    //   })
-    //   const transaction = await signTransaction(rawTransaction, peernet.identity)
-    //   tx = await chain.sendTransaction(transaction)
-    //   console.log({tx});
-    //   await tx.wait
-    // } catch (e) {
-    //   console.log({e});
-    // }
-    // return
-    console.log({nonce});
-    let balances = await chain.balances
-    console.log({balances});
-    // return
-    // console.log(`balance for ${Object.keys(balances)[0]}:${chain.utils.formatUnits(balances[Object.keys(balances)[0]]).toString()}`);
-    // console.log(`balance for ${Object.keys(balances)[1]}:${chain.utils.formatUnits(balances[Object.keys(balances)[1]]).toString()}`);
-    // return
-    let promises = []
-    // nonce += 
-    nonce = await chain.getNonce(peernet.selectedAccount)
-    for (let i = 0; i < 10; i++) {
-      // contract , method, from, to, amount, (optional) nonce
-      nonce += 1
-      const rawTransaction = await chain.createTransaction({
-        from: peernet.selectedAccount, 
-        to: chain.nativeToken, 
-        method: 'transfer',
-        nonce,
-        params: [peernet.selectedAccount, '6zqut21djrRNJAniaTByovGhnBGs5h9wfkP35mzjZkEBZwnQVo', chain.utils.parseUnits('100').toString()]
-      })
-      const transaction = await signTransaction(rawTransaction, peernet.identity)
-      promises.push(chain.sendTransaction(transaction))
-    }
-    promises = await Promise.allSettled(promises)
-    promises = await Promise.allSettled(promises.map(({value}) => value.wait))
-
-    console.log(`${(new Date().getTime() - start) / 1000} s`);
-
-    balances = await chain.balances
-    console.log(`balance for ${Object.keys(balances)[0]}:${chain.utils.formatUnits(balances[Object.keys(balances)[0]]).toString()}`);
-    console.log(`balance for ${Object.keys(balances)[1]}:${chain.utils.formatUnits(balances[Object.keys(balances)[1]]).toString()}`);
-// return
-//     // setTimeout(async () => {
-    promises = []
-    nonce = await chain.getNonce(peernet.selectedAccount)
-    // nonce += 1
-    for (let i = 0; i < 10; i++) {
-      // contract , method, from, to, amount, (optional) nonce
-      nonce += 1
-      const rawTransaction = await chain.createTransaction({
-        from: peernet.selectedAccount, 
-        to: chain.nativeToken, 
-        method: 'transfer',
-        nonce,
-        params: [peernet.selectedAccount, '6zqut21djrRNJAniaTByovGhnBGs5h9wfkP35mzjZkEBZwnQVo', chain.utils.parseUnits('100').toString()]
-      })
-      const transaction = await signTransaction(rawTransaction, peernet.identity)
-      promises.push(chain.sendTransaction(transaction))
-    }
-    promises = await Promise.allSettled(promises)
-    promises = await Promise.allSettled(promises.map(({value}) => value.wait))
-    balances = await chain.balances
-    console.log(`balance for ${Object.keys(balances)[0]}:${chain.utils.formatUnits(balances[Object.keys(balances)[0]]).toString()}`);
-    console.log(`balance for ${Object.keys(balances)[1]}:${chain.utils.formatUnits(balances[Object.keys(balances)[1]]).toString()}`);
-
-    promises = []
-    nonce = await chain.getNonce(peernet.selectedAccount)
-
-    const createSignSendTransaction = async (nonce) => {
-      const rawTransaction = await chain.createTransaction({
-        from: peernet.selectedAccount, 
-        to: chain.nativeToken, 
-        method: 'transfer',
-        nonce,
-        params: [peernet.selectedAccount, '6zqut21djrRNJAniaTByovGhnBGs5h9wfkP35mzjZkEBZwnQVo', chain.utils.parseUnits('100').toString()]
-      })
-      const transaction = await signTransaction(rawTransaction, peernet.identity)
-      return chain.sendTransaction(transaction)
-    }
-    // nonce += 1
-    for (let i = 0; i < 1000; i++) {
-      nonce += 1
-      promises.push(createSignSendTransaction(nonce))
-    }
-    promises = await Promise.allSettled(promises)
-    promises = await Promise.allSettled(promises.map(({value}) => value.wait))
-    balances = await chain.balances
-    console.log(`balance for ${Object.keys(balances)[0]}:${chain.utils.formatUnits(balances[Object.keys(balances)[0]]).toString()}`);
-    console.log(`balance for ${Object.keys(balances)[1]}:${chain.utils.formatUnits(balances[Object.keys(balances)[1]]).toString()}`);
-      // }, 10000);
-
-// job()
-  // }, 5000);
-}
-
-// setTimeout(function () {
-//   start = new Date().getTime()
-//   console.log(peernet.connections);
-// }, 10000);
-  try {
-    job()
-  } catch (e) {
-    console.warn(e);
-  }
-

package/test/contracts/token.js

@@ -1,40 +0,0 @@
-const test = require('tape')
-
-const Token = require('./../../dist/token');
-
-class TestToken extends Token {
-  constructor() {
-    super('token', 'TKN')
-  }
-}
-
-
-// const token = new TestToken()
-
-test("can't access private", tape => {
-  tape.plan(3)
-  token.holders = 5
-  token.balances[0] = 100
-  token.symbol = 'TTT'
-console.log(token.symbol);
-  tape.ok(token.symbol === 'TKN', 'symbol')
-  tape.ok(Object.keys(token.balances).length === 0, 'balances')
-  tape.ok(token.holders === 0, 'holders')
-})
-
-// test("transfer", tape => {
-//   tape.plan(1)
-// console.log(token.balances);
-//   try {
-//     token.transfer('0', '1', 100)
-//   } catch (e) {
-// console.log(e);
-//   } finally {
-//
-//   }
-//   console.log(token.balances);
-//
-//   tape.ok(token.balances[1] === 100)
-// })
-
-// console.log(new NativeToken());

package/test/create-genesis.js

@@ -1,66 +0,0 @@
-
-  console.log('run');
-
-(async () => {
-  console.log('run');
-  const {promisify} = require('util')
-  const read = promisify(require('fs').readFile)
-  const write = promisify(require('fs').writeFile)
-  const {join} = require('path')
-  console.log('t');
-  const Chain = require('./../dist/chain');
-  console.log(Chain);
-  const Node = require('./../dist/node');
-  console.log(Node);
-  console.log(Chain);
-  const node = await new Node()
-  console.log(node);
-  const chain = await new Chain()
-  console.log(chain);
-  const createMessage = async (src, params = []) => {
-    const contract = await read(src)
-    return chain.createContractMessage(peernet.id, `return ${contract.toString().replace(/export{([A-Z])\w+ as default}/g, '')}`, params)
-  }
-  const factory = await createMessage('./dist/contracts/factory.js')
-  console.log(factory);
-  if (!await contractStore.has(factory.hash)) {
-    await contractStore.put(factory.hash, factory.encoded)
-  }
-
-  const nativeToken = await createMessage('./dist/contracts/nativeToken.js')
-  if (!await contractStore.has(nativeToken.hash)) {
-    await contractStore.put(nativeToken.hash, nativeToken.encoded)
-  }
-
-
-  const validators = await createMessage('./dist/contracts/validators.js', [nativeToken.hash])
-
-  if (!await contractStore.has(validators.hash)) {
-    await contractStore.put(validators.hash, validators.encoded)
-  }
-
-
-  const nameService = await createMessage('./dist/contracts/nameService.js', [factory.hash, nativeToken.hash, validators.hash, BigNumber.from('1000')])
-
-  if (!await contractStore.has(nameService.hash)) {
-    await contractStore.put(nameService.hash, nameService.encoded)
-  }
-  const addresses = {
-    contractFactory: factory.hash,
-    nativeToken: nativeToken.hash,
-    nameService: nameService.hash,
-    validators: validators.hash
-  }
-
-
-
-  const bytecodes = {
-    contractFactory: await factory.toString(),
-    nativeToken: await nativeToken.toString(),
-    nameService: await nameService.toString(),
-    validators: await validators.toString()
-  }
-
-  await write(join(process.cwd(), 'src/addresses.json'), JSON.stringify(addresses, null, '\t'))
-  await write(join(process.cwd(), 'src/bytecodes.json'), JSON.stringify(bytecodes, null, '\t'))
-})()

package/test/index.js

@@ -1 +0,0 @@
-import './chain.js'

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "compilerOptions": {
-    "module": "es2022",
-    "target": "es2022",
-    "outDir": "./exports",
-    "moduleResolution":"NodeNext",
-    "declaration": true,
-    "declarationDir": "./exports/typings",
-    "allowJs": true,
-    "allowSyntheticDefaultImports": true,    
-    "resolveJsonModule": true
-  },
-  "include": [
-    "./src/**/*"
-  ],
-  "exclude": ["./node_modules"]
-}

package/workers/block-worker.js

@@ -1,40 +0,0 @@
-import { BlockMessage } from './../../messages/src/messages.js'
-import { formatBytes, BigNumber } from './../../utils/src/utils.js'
-
-import EasyWorker from '@vandeurenglenn/easy-worker'
-
-const worker = new EasyWorker()
-
-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) => {
-    // todo: tx worker or nah?
-    const size = block.encoded.length || block.encoded.byteLength
-    console.log(`loaded block: ${await block.hash} @${block.decoded.index} ${formatBytes(size)}`);
-    resolve(block)
-  })))
-  return blocks
-}
-
-const tasks = async blocks => {
-  globalThis.peernet.codecs =  {
-    'block-message': {
-      codec: parseInt('626d', 16),
-      hashAlg: 'keccak-256'
-    }
-  }  
-  
-  blocks = await run(blocks)
-  worker.postMessage(blocks)
-}
- 
-
-worker.onmessage(data => tasks(data))
-

package/workers/machine-worker.js

@@ -1,219 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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