@leofcoin/chain 1.0.21 → 1.0.24

package/src/machine.js

@@ -1,6 +1,7 @@
 import vm from 'vm'
-import { ContractMessage, TransactionMessage } from '@leofcoin/messages'
-import lib from '@leofcoin/lib'
+import { ContractMessage } from './../../messages/src/messages'
+import { contractFactory, nativeToken, validators, nameService } from './../../addresses/src/addresses.json'
+import { formatBytes } from './../../utils/src/utils'
 // import State from './state'
 
 export default class Machine {
@@ -22,15 +23,18 @@ export default class Machine {
     // return
     try {
       let contracts = [
-        contractStore.get(lib.contractFactory),
-        contractStore.get(lib.nativeToken),
-        contractStore.get(lib.validators),
-        contractStore.get(lib.nameService)
+        contractStore.get(contractFactory),
+        contractStore.get(nativeToken),
+        contractStore.get(validators),
+        contractStore.get(nameService)
       ]
 
       contracts = await Promise.all(contracts)
+      console.log(contracts);
       for (const contract of contracts) {
-        const message = new ContractMessage(new Uint8Array(contract.buffer, contract.buffer.byteOffset, contract.buffer.byteLength))
+
+        const message = await new ContractMessage(new Uint8Array(contract.buffer, contract.buffer.byteOffset, contract.buffer.byteLength))
+        console.log(message);
         await this.#runContract(message)
       }
     } catch (e) {
@@ -51,6 +55,7 @@ console.log(e);
   }
 
   async #runContract(contractMessage) {
+    console.log(contractMessage);
     const params = contractMessage.decoded.constructorParameters
     try {
 
@@ -59,16 +64,15 @@ console.log(e);
 
       globalThis.msg = this.#createMessage(contractMessage.decoded.creator)
       // globalThis.msg = {sender: contractMessage.decoded.creator}
-      this.#contracts[contractMessage.hash] = new Contract(...params)
-      debug(`loaded contract: ${contractMessage.hash}`);
-      debug(`size: ${Math.round((contractMessage.encoded.length / 1024) * 100) / 100} kb`);
+      this.#contracts[await contractMessage.hash] = await new Contract(...params)
+      debug(`loaded contract: ${await contractMessage.hash}`);
+      debug(`size: ${formatBytes(contractMessage.encoded.length)}`);
     } catch (e) {
       console.log(e);
       console.warn(`removing contract ${contractMessage.hash}`);
       await contractStore.delete(contractMessage.hash, contractMessage.encoded)
     }
   }
-
   /**
    * @params {ContractMessage} - contractMessage
    */

package/src/node.js

@@ -1,7 +1,5 @@
 // import config from './config/config'
 import Peernet from '@leofcoin/peernet'
-import lib from '@leofcoin/lib'
-const { ContractMessage, TransactionMessage, BlockMessage, BWMessage, BWRequestMessage } = lib
 
 export default class Node {
   constructor() {
@@ -10,44 +8,13 @@ export default class Node {
 
   async _init(config = {
     network: 'leofcoin',
-    root: '.artonline',
-    networkName: 'leofcoin:olivia',
+    root: '.leofcoin',
+    networkName: 'leofcoin:mandarine',
     networkVersion: 'v0.1.0'
   }) {
     globalThis.Peernet ? await new globalThis.Peernet(config) : await new Peernet(config)
 
-    await peernet.addProto('contract-message', ContractMessage)
-    await peernet.addProto('transaction-message', TransactionMessage)
-    await peernet.addProto('block-message', BlockMessage)
-    await peernet.addProto('bw-message', BWMessage)
-    await peernet.addProto('bw-request-message', BWRequestMessage)
 
-    await peernet.addCodec('contract-message', {
-      codec: parseInt('636d', 16),
-      hashAlg: 'keccak-256'
-    })
-    await peernet.addCodec('transaction-message', {
-      codec: parseInt('746d', 16),
-      hashAlg: 'keccak-256'
-    })
-
-    await peernet.addCodec('block-message', {
-      codec: parseInt('626d', 16),
-      hashAlg: 'keccak-256'
-    })
-
-    await peernet.addCodec('bw-message', {
-      codec: parseInt('62776d', 16),
-      hashAlg: 'keccak-256'
-    })
-
-    await peernet.addCodec('bw-request-message', {
-      codec: parseInt('6277726d', 16),
-      hashAlg: 'keccak-256'
-    })
-
-    await peernet.addStore('contract', 'art', '.ArtOnline', false)
-    await peernet.addStore('transactionPool', 'art', '.ArtOnline', false)
     return this
     // this.config = await config()
   }

package/src/state.js

@@ -14,13 +14,18 @@ export default class State {
   //   return this
   // }
 
-  async put(key, value, isCompressed = false) {
+  async put(key, value, isCompressed = true) {
     value = isCompressed ? isCompressed : await pako.deflate(value)
     await stateStore.put(key, value)
   }
 
-  async get(key) {
+  async get(key, isCompressed = true) {
     const value = await stateStore.get(key)
-    return pako.inflate(value)
+    return isCompressed = true ? pako.inflate(value) : value
+  }
+
+  updateState(block) {
+    // block.decoded.index
+    this.#isUpdateNeeded()
   }
 }

package/src/transactions/transaction.js

@@ -0,0 +1,3 @@
+export default () => {
+  
+}

package/test/chain.js

@@ -1,3 +1,4 @@
+const { nodeConfig } = require('../../lib/dist/lib');
 
 
 (async () => {
@@ -5,6 +6,7 @@
   const Chain = require('./../dist/chain');
   const Node = require('./../dist/node');
   const node = await new Node()
+  await nodeConfig()
   const chain = await new Chain()
   let start
   //
@@ -22,89 +24,65 @@
   // '5xdacigaguxg3yjllehp65htk32ha3sztlexxrrhmviobgibz6dt6hkxfu'
 
       await chain.participate()
-      // let balances = chain.balances
-      // console.log({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()}`);
 const job = async () => {
   setTimeout(async () => {
-
     let tx
-  try {
-    tx = await chain.createTransaction(chain.nativeToken, 'grantRole', [peernet.id, 'MINT'])
-    await tx.wait()
+    // try {
+    //   tx = await chain.createTransaction(chain.nativeToken, 'grantRole', [peernet.id, 'MINT'])
+    //   await tx.wait()
 
+    // } catch (e) {
+    //   console.log(e);
+    // }
 
-  } catch (e) {
-    console.log(e);
-  }
+    // try {
+    //   tx = await chain.createTransaction(chain.nativeToken, 'mint', [peernet.id, chain.utils.parseUnits('100000000000000').toString()])
 
-  try {
-    tx = await chain.createTransaction(chain.nativeToken, 'mint', [peernet.id, chain.utils.parseUnits('1000000000').toString()])
-    await tx.wait()
-  } catch (e) {
-    console.log(e);
-  }
+    //   await tx.wait()
+    // } catch (e) {
+    //   console.log(e);
+    // }
+    // return
+    let nonce = await chain.getNonce(peernet.id)
+    console.log({nonce});
     let promises = []
     // nonce += 1
     for (let i = 0; i < 10; i++) {
       // contract , method, from, to, amount, (optional) nonce
-      promises.push(chain.createTransaction(chain.nativeToken, 'transfer', [peernet.id, '3CzV5vEE3nceXUXe8vTpRz95dBhL8V54zKjAGd8YxjCmdW2J8ZxrYw', chain.utils.parseUnits('100').toString()]))
+      nonce += 1
+      promises.push(chain.createTransaction(chain.nativeToken, 'transfer', [peernet.id, '3CzV5vEE3nceXUXe8vTpRz95dBhL8V54zKjAGd8YxjCmdW2J8ZxrYw', chain.utils.parseUnits('100').toString()], nonce))
     }
-promises = await Promise.allSettled(promises)
-console.log({promises});
-promises = await Promise.allSettled(promises.map(({value}) => value.wait()))
-console.log({promises});
-promises.forEach((item, i) => {
-  if (item.reason) console.log(item.reason);
-});
-
-console.log(promises[1].reason);
-// console.log(promises);
-// await promises[promises.length - 1].value.wait()
-// promises = []
-//     for (let i = 0; i < 50; i++) {
-//       promises.push(chain.createTransaction(chain.nativeToken, 'transfer', ['0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000001', 100]))
-//     }
+    promises = await Promise.allSettled(promises)
+    promises = await Promise.allSettled(promises.map(({value}) => value.wait()))
+    promises.forEach((item, i) => {
+      if (item.reason) console.log(item.reason);
+    });
 
-//   promises = await Promise.all(promises)
-// await promises[promises.length - 1].wait()
-console.log(`${(new Date().getTime() - start) / 1000} s`);
-// setTimeout(function () {
-//   const balances =  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()}`);
-//
-// }, 30000);
-    // console.log({tx});
-    // let result =  chain.mint('0x0000000000000000000000000000000000000000', 100)
-    // result =  chain.transfer('0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000001', 100)
+    console.log(`${(new Date().getTime() - start) / 1000} s`);
 
+    balances = 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()}`);
 
-      balances = chain.balances
-      console.log({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()}`);
+    // setTimeout(async () => {
+    promises = []
 
-      // setTimeout(async () => {
-        promises = []
-        console.log('run');
-        // nonce += 1
-        for (let i = 0; i < 100; i++) {
-          // contract , method, from, to, amount, (optional) nonce
-          promises.push(chain.createTransaction(chain.nativeToken, 'transfer', [peernet.id, '3CzV5vEE3nceXUXe8vTpRz95dBhL8V54zKjAGd8YxjCmdW2J8ZxrYw', chain.utils.parseUnits('100').toString()]))
-          // nonce += 1
-        }
+    // nonce += 1
+    for (let i = 0; i < 10000; i++) {
+      // contract , method, from, to, amount, (optional) nonce
+      
+      nonce += 1
+      promises.push(chain.createTransaction(chain.nativeToken, 'transfer', [peernet.id, '3CzV5vEE3nceXUXe8vTpRz95dBhL8V54zKjAGd8YxjCmdW2J8ZxrYw', chain.utils.parseUnits('100').toString()], nonce))
+    }
     promises = await Promise.allSettled(promises)
     promises = await Promise.allSettled(promises.map(({value}) => value.wait()))
     balances = chain.balances
-    console.log({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);
+  }, 5000);
 }
 
 setTimeout(function () {
@@ -116,4 +94,5 @@ setTimeout(function () {
   } catch (e) {
     console.warn(e);
   }
+  return peernet
 })()

package/webpack.config.js

@@ -1,44 +1,11 @@
 const path = require('path');
 const webpack = require('webpack');
 module.exports = [{
-  entry: './src/chain.js',
-  plugins: [
-    // Work around for Buffer is undefined:
-    // https://github.com/webpack/changelog-v5/issues/10
-    new webpack.ProvidePlugin({
-        Buffer: ['buffer', 'Buffer'],
-    }),
-    new webpack.ProvidePlugin({
-        process: 'process/browser',
-  })
-  ],
-  optimization: {
-    minimize: false
+  mode: 'production',
+  entry: {
+    chain: './src/chain.js',
+    node: './src/node.js'
   },
-  resolve: {
-    // extensions: [ '.ts', '.js' ],
-    fallback: {
-      vm: require.resolve("vm-browserify"),
-      // "stream": require.resolve("stream-browserify"),
-      "buffer": require.resolve("buffer")
-      // fs: false,
-      // "path": require.resolve("path-browserify"),
-      // "util": require.resolve("util/"),
-      // "assert": require.resolve("assert/"),
-    }
-  },
-  output: {
-    library: {
-      type: 'module'
-    },
-    filename: 'chain.browser.js',
-    path: path.resolve(__dirname, 'dist'),
-  },
-  experiments: {
-    outputModule: true
-  }
-}, {
-  entry: './src/chain.js',
   plugins: [
     // Work around for Buffer is undefined:
     // https://github.com/webpack/changelog-v5/issues/10
@@ -47,60 +14,7 @@ module.exports = [{
     }),
     new webpack.ProvidePlugin({
         process: 'process/browser',
-  })
-  ],
-  optimization: {
-    minimize: true
-  },
-  resolve: {
-    // extensions: [ '.ts', '.js' ],
-    fallback: {
-      vm: require.resolve("vm-browserify"),
-      // "stream": require.resolve("stream-browserify"),
-      "buffer": require.resolve("buffer")
-      // fs: false,
-      // "path": require.resolve("path-browserify"),
-      // "util": require.resolve("util/"),
-      // "assert": require.resolve("assert/"),
-    }
-  },
-  output: {
-    library: {
-      type: 'module'
-    },
-    filename: 'chain.browser.min.js',
-    path: path.resolve(__dirname, 'dist'),
-  },
-  experiments: {
-    outputModule: true
-  }
-}, {
-  entry: './src/chain.js',
-  optimization: {
-    minimize: true
-  },
-  output: {
-    library: {
-      type: 'module'
-    },
-    filename: 'chain.esm',
-    path: path.resolve(__dirname, 'dist'),
-  },
-  experiments: {
-    outputModule: true
-  }
-}, {
-  entry: './src/node.js',
-  plugins: [
-    // Work around for Buffer is undefined:
-    // https://github.com/webpack/changelog-v5/issues/10
-    // new webpack.ProvidePlugin({
-    //     Buffer: ['buffer', 'Buffer'],
-    // }),
-    new webpack.ProvidePlugin({
-      process: 'process/browser',
     }),
-
     new webpack.ProvidePlugin({
       WRTC_IMPORT: `globalThis.wrtc = {
         RTCPeerConnection,
@@ -115,65 +29,21 @@ module.exports = [{
   resolve: {
     // extensions: [ '.ts', '.js' ],
     fallback: {
+      vm: require.resolve("vm-browserify"),
       // "stream": require.resolve("stream-browserify"),
-      // "buffer": require.resolve("buffer"),
-      // fs: false,
-      // "path": require.resolve("path-browserify"),
-      // "util": require.resolve("util/"),
-      // "assert": require.resolve("assert/"),
-
-    }
-  },
-  output: {
-    library: {
-      type: 'module'
-    },
-    filename: 'node.browser.js',
-    path: path.resolve(__dirname, 'dist'),
-  },
-  experiments: {
-    outputModule: true
-  }
-}, {
-  entry: './src/node.js',
-  plugins: [
-    // Work around for Buffer is undefined:
-    // https://github.com/webpack/changelog-v5/issues/10
-    // new webpack.ProvidePlugin({
-    //     Buffer: ['buffer', 'Buffer'],
-    // }),
-    new webpack.ProvidePlugin({
-      process: 'process/browser',
-    }),
-
-    new webpack.ProvidePlugin({
-      WRTC_IMPORT: `globalThis.wrtc = {
-        RTCPeerConnection,
-        RTCSessionDescription,
-        RTCIceCandidate
-      }`
-    })
-  ],
-  optimization: {
-    minimize: true
-  },
-  resolve: {
-    // extensions: [ '.ts', '.js' ],
-    fallback: {
-      // "stream": require.resolve("stream-browserify"),
-      // "buffer": require.resolve("buffer"),
-      // fs: false,
+      "buffer": require.resolve("buffer"),
+      fs: false,
       // "path": require.resolve("path-browserify"),
-      // "util": require.resolve("util/"),
+      "util": false,
       // "assert": require.resolve("assert/"),
-
     }
   },
   output: {
     library: {
       type: 'module'
     },
-    filename: 'node.browser.min.js',
+    filename: '[name].browser.js',
+    chunkFilename: '[name].browser.js',
     path: path.resolve(__dirname, 'dist'),
   },
   experiments: {