@leofcoin/chain 1.0.4

package/src/protos/block.proto.js

@@ -0,0 +1,26 @@
+export default `
+message ValidatorMessage {
+  required string address = 1;
+  required string reward = 2;
+}
+
+message Transaction {
+  required string hash = 1;
+  required uint64 timestamp = 2;
+  required string from = 3;
+  required string to = 4;
+  required uint64 nonce = 5;
+  required string method = 6;
+  repeated string params = 7;
+}
+
+message BlockMessage {
+  required uint64 index = 1;
+  required string previousHash = 3;
+  required uint64 timestamp = 4;
+  required uint64 reward = 5;
+  required string fees = 6;
+  repeated Transaction transactions = 7;
+  repeated ValidatorMessage validators = 8;
+}
+`

package/src/protos/bw-request.proto.js

@@ -0,0 +1,5 @@
+export default `
+
+message BWRequestMessage {
+}
+`

package/src/protos/bw.proto.js

@@ -0,0 +1,7 @@
+export default `
+
+message BWMessage {
+  required uint64 up = 1;
+  required uint64 down = 2;
+}
+`

package/src/protos/contract.proto.js

@@ -0,0 +1,7 @@
+export default `
+message ContractMessage {
+  required string creator = 1;
+  required bytes contract = 2;
+  repeated string constructorParameters = 3;
+}
+`

package/src/protos/last-block-request.proto.js

@@ -0,0 +1,5 @@
+export default `
+
+message LastBlockRequestMessage {
+}
+`

package/src/protos/last-block.proto.js

@@ -0,0 +1,7 @@
+export default `
+
+message LastBlockMessage {
+  required string hash = 1;
+  required uint64 index = 2;
+}
+`

package/src/protos/transaction.proto.js

@@ -0,0 +1,11 @@
+export default `
+
+message TransactionMessage {
+  required uint64 timestamp = 1;
+  required string from = 2;
+  required string to = 3;
+  required uint64 nonce = 4;
+  required string method = 5;
+  repeated string params = 6;
+}
+`

package/src/standards/Proxy.js

@@ -0,0 +1,42 @@
+import Roles from './roles.js'
+
+export default class Proxy extends Roles {
+  #proxyManager
+  #implementation
+
+  constructor(proxyManager, state) {
+    super(state?.roles)
+    if (state) {
+      this.#proxyManager = state.proxyManager
+    } else {
+      this.#proxyManager = proxyManager
+    }
+  }
+
+  get state() {
+    return {
+      ...super.state,
+      proxyManager: this.#proxyManager,
+      implementation: this.#implementation
+    }
+  }
+
+  async setImplementation(address) {
+    if (msg.sender !== this.#proxyManager) throw new Error(`not allowed, expected proxy manager`)
+
+    const state = await stateStore.get(this.#implementation)
+    await stateStore.put(address, state)
+    stateStore.delete(this.#implementation)
+    this.#implementation = address
+  }
+
+  async changeProxyManager(address) {
+    if (msg.sender !== this.#proxyManager) throw new Error(`not allowed, expected proxy manager`)
+    this.#proxyManager = address
+  }
+
+  fallback(method, params) {
+    if (msg.sender === this.proxyManager) return this[method](...params)
+    return msg.internalCall(msg.sender, this.#implementation, method, params)
+  }
+}

package/src/standards/Voting.js

@@ -0,0 +1,3 @@
+export default class ArtOnlineVoting {
+
+}

package/src/standards/initializer.js

@@ -0,0 +1,10 @@
+export default class Initializer {
+  #initialized = false
+  constructor() {
+    this.#initialized = true
+  }
+
+  get initialized() {
+    return this.#initialized
+  }
+}

package/src/standards/proxyManager.js

@@ -0,0 +1,66 @@
+import Roles from './roles.js'
+
+export default class ProxyManager extends Roles {
+  #name
+  #proxies = {}
+  #manager
+
+
+  constructor(name, state) {
+    super(state?.roles)
+    this.#name = name
+
+    if (state) {
+      this.#proxies = state.proxies
+      this.#manager = state.manager
+    } else {
+      this.#manager = msg.sender
+    }
+  }
+
+  /**
+   *
+   */
+  async #upgradeProxy(proxy, address) {
+    await msg.internalCall(this.#manager, proxy, 'setImplementation', [address])
+    this.#proxies[proxy] = address
+  }
+
+  /**
+   *
+   */
+  upgradeProxy(proxy, address) {
+    if (!this.hasRole(msg.sender, 'MANAGER')) throw new Error('Not allowed, expected MANAGER')
+    this.#upgradeProxy(proxy, address)
+  }
+
+  async #changeManager(address) {
+    this.#revokeRole(this.#manager, 'MANAGER')
+    this.#grantRole(address, 'MANAGER')
+    for (const proxy of Object.keys(this.#proxies)) {
+      await msg.internalCall(this.#manager, proxy, 'changeProxyManager', [address])
+    }
+    this.#manager = address
+  }
+
+  changeManager(address) {
+    if (!this.hasRole(msg.sender, 'OWNER')) throw new Error('Not allowed, expected OWNER')
+    return this.#changeManager(address)
+  }
+
+  get state() {
+    return {
+      ...super.state,
+      proxies: this.proxies,
+      manager: this.manager
+    }
+  }
+
+  get manager() {
+    return this.#manager
+  }
+
+  get proxies() {
+    return { ...this.#proxies }
+  }
+}

package/src/standards/roles.js

@@ -0,0 +1,65 @@
+export default class Roles {
+
+  /**
+   * Object => Array
+   */
+  #roles = {
+    'OWNER': [],
+    'MINT': [],
+    'BURN': []
+  }
+
+  constructor(roles) {
+    // allow devs to set their own roles but always keep the default ones included
+    // also allows roles to be loaded from the stateStore
+    // carefull when includin gthe roles make sure to add the owner
+    // since no roles are granted by default when using custom roles
+    if (roles) {
+      if (roles instanceof Object) {
+       this.#roles = {...roles, ...this.#roles}
+      } else {
+       throw new Error(`expected roles to be an object`)
+      }
+    } else {
+      // no roles given so default to the msg sender
+      this.#grantRole(msg.sender, 'OWNER')
+    }
+  }
+
+  get state() {
+    return { roles: this.roles }
+  }
+
+  get roles() {
+    return {...this.#roles}
+  }
+
+  hasRole(address, role) {
+    return this.#roles[role] ? this.#roles[role].indexOf(address) !== -1 : false
+  }
+
+  #grantRole(address, role) {
+    if (this.hasRole(address, role)) throw new Error(`${role} role already granted for ${address}`)
+
+    this.#roles[role].push(address)
+  }
+
+  #revokeRole(address, role) {
+    if (!this.hasRole(address, role)) throw new Error(`${role} role already revoked for ${address}`)
+    if (role === 'OWNER' && this.#roles[role].length === 1) throw new Error(`atleast one owner is needed!`)
+
+    this.#roles[role].splice(this.#roles[role].indexOf(address))
+  }
+
+  grantRole(address, role) {
+    if (!this.hasRole(address, 'OWNER')) throw new Error('Not allowed')
+
+    this.#grantRole(address, role)
+  }
+
+  revokeRole(address, role) {
+    if (!this.hasRole(address, 'OWNER')) throw new Error('Not allowed')
+
+    this.#revokeRole(address, role)
+  }
+}

package/src/standards/token.js

@@ -0,0 +1,137 @@
+import Roles from './roles.js'
+
+export default class Token extends Roles {
+  /**
+   * string
+   */
+  #name
+  /**
+   * String
+   */
+  #symbol
+  /**
+   * uint
+   */
+  #holders = 0
+  /**
+   * Object => Object => uint
+   */
+  #balances = {}
+  /**
+   * Object => Object => uint
+   */
+  #approvals = {}
+
+  #decimals = 18
+
+  #totalSupply = BigNumber.from(0)
+
+    // this.#privateField2 = 1
+  constructor(name, symbol, decimals = 18, state) {
+    if (!name) throw new Error(`name undefined`)
+    if (!symbol) throw new Error(`symbol undefined`)
+
+    super(state?.roles)
+
+    this.#name = name
+    this.#symbol = symbol
+    this.#decimals = decimals
+  }
+
+  // enables snapshotting
+  // needs dev attention so nothing breaks after snapshot happens
+  // iow everything that is not static needs to be included in the stateObject
+  /**
+   * @return {Object} {holders, balances, ...}
+   */
+  get state() {
+    return {
+      ...super.state,
+      holders: this.holders,
+      balances: this.balances,
+      approvals: { ...this.#approvals },
+      totalSupply: this.totalSupply
+    }
+  }
+
+  get totalSupply() {
+    return this.#totalSupply
+  }
+
+  get name() {
+    return this.#name
+  }
+
+  get symbol() {
+    return this.#symbol
+  }
+
+  get holders() {
+    return this.#holders
+  }
+
+  get balances() {
+    return {...this.#balances}
+  }
+
+  mint(to, amount) {
+    if (!this.hasRole(msg.sender, 'MINT')) throw new Error('not allowed')
+
+    this.#totalSupply = this.#totalSupply.add(amount)
+    this.#increaseBalance(to, amount)
+  }
+
+  burn(to, amount) {
+    if (!this.hasRole(msg.sender, 'BURN')) throw new Error('not allowed')
+
+    this.#totalSupply = this.#totalSupply.sub(amount)
+    this.#decreaseBalance(to, amount)
+  }
+
+  #beforeTransfer(from, to, amount) {
+    if (!this.#balances[from] || this.#balances[from] < amount) throw new Error('amount exceeds balance')
+  }
+
+  #updateHolders(address, previousBalance) {
+    if (this.#balances[address].toHexString() === '0x00') this.#holders -= 1
+    else if (this.#balances[address].toHexString() !== '0x00' && previousBalance.toHexString() === '0x00') this.#holders += 1
+  }
+
+  #increaseBalance(address, amount) {
+    if (!this.#balances[address]) this.#balances[address] = BigNumber.from(0)
+    const previousBalance = this.#balances[address]
+
+    this.#balances[address] = this.#balances[address].add(amount)
+    this.#updateHolders(address, previousBalance)
+  }
+
+  #decreaseBalance(address, amount) {
+    const previousBalance = this.#balances[address]
+    this.#balances[address] = this.#balances[address].sub(amount)
+    this.#updateHolders(address, previousBalance)
+  }
+
+  balanceOf(address) {
+    return this.#balances[address]
+  }
+
+  setApproval(operator, amount) {
+    const owner = globalThis.msg.sender
+    if (!this.#approvals[owner]) this.#approvals[owner] = {}
+    this.#approvals[owner][operator] = amount
+  }
+
+  approved(owner, operator, amount) {
+    return this.#approvals[owner][operator] === amount
+  }
+
+  transfer(from, to, amount) {
+    // TODO: is BigNumber?
+    amount = BigNumber.from(amount)
+    this.#beforeTransfer(from, to, amount)
+    this.#decreaseBalance(from, amount)
+    this.#increaseBalance(to, amount)
+  }
+
+
+}

package/src/state.js

@@ -0,0 +1,26 @@
+import pako from 'pako'
+
+export default class State {
+  constructor() {
+    // return this.#init()
+  }
+
+  // async #init() {
+  //   const state = await stateStore.get()
+  //   for (const [key, value] of Object.entries(state)) {
+  //
+  //   }
+  //
+  //   return this
+  // }
+
+  async put(key, value, isCompressed = false) {
+    value = isCompressed ? isCompressed : await pako.deflate(value)
+    await stateStore.put(key, value)
+  }
+
+  async get(key) {
+    const value = await stateStore.get(key)
+    return pako.inflate(value)
+  }
+}

package/src/transactions/validator.js

@@ -0,0 +1,29 @@
+import hasher from './crypto/hasher'
+import {create} from './crypto/transaction'
+
+export default class Validator {
+  constructor(address) {
+    this._init(address)
+  }
+
+  async _init(address) {
+    const valid = await this.isValid(address, this)
+    if (!valid) throw new Error('Invalid validator')
+    return this
+  }
+
+  async isValid(hash, transaction) {
+    return this.validateTransaction(hash, transaction)
+  }
+
+  async validateTransaction(hash, transaction) {
+    delete transaction.hash
+    transaction = await create(hasher.hash(transaction))
+    if (transaction !== hash) throw Error('invalid hash')
+    // for (const input of transaction) {
+    //   input
+    // }
+    return true
+
+  }
+}

package/src/typer.js

@@ -0,0 +1,19 @@
+import {BigNumber} from './utils/utils'
+
+const codec = '0x'
+
+const isAddress = address => {
+  if (!address.startsWith(codec)) return false
+  if (address.length !== 64) return false
+}
+
+export default {
+  isType: (type, value) => {
+    type = type.toLowercase()
+    if (type === 'string') return typeof(value) === type
+    if (type === 'number') return !isNaN(Number(value))
+    if (type === 'address') return isAddress(value)
+    if (type === 'BigNumber') return BigNumber.isBigNumber(value)
+  },
+  isAddress
+}

package/src/utils/utils.js

@@ -0,0 +1,16 @@
+// import { promisify } from 'util'
+// import { writeFile, readFile } from 'fs'
+export { BigNumber } from "@ethersproject/bignumber";
+export { formatUnits, parseUnits } from '@ethersproject/units'
+import chalk from 'chalk'
+
+const info = text => console.log(chalk.blueBright(text))
+
+const subinfo = text => console.log(chalk.magentaBright(text))
+
+export {
+  info,
+  subinfo
+}
+// export const write = promisify(writeFile)
+// export const read = promisify(readFile)

package/test/chain.js

@@ -0,0 +1,119 @@
+
+
+(async () => {
+  globalThis.DEBUG = true
+  const Chain = require('./../dist/chain');
+  const Node = require('./../dist/node');
+  const node = await new Node()
+  const chain = await new Chain()
+  let start
+  //
+  // await chain.deleteAll()
+  // return
+//   try {
+//     const contract = await chain.utils.read('./dist/native.js')
+//     const address = await chain.deployContract(peernet.Buffer.from(`return ${contract.toString().replace(/export{([A-Z])\w+ as default}/g, '')}`))
+//     console.log(address);
+//   } catch (e) {
+// console.log(e);
+//   } finally {
+//
+//   }
+  // '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()
+
+
+  } catch (e) {
+    console.log(e);
+  }
+
+  try {
+    tx = await chain.createTransaction(chain.nativeToken, 'mint', [peernet.id, chain.utils.parseUnits('1000000000').toString()])
+    await tx.wait()
+  } catch (e) {
+    console.log(e);
+  }
+    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()]))
+    }
+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.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)
+
+
+      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 = []
+        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
+        }
+    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);
+}
+
+setTimeout(function () {
+  start = new Date().getTime()
+  console.log(peernet.connections);
+}, 10000);
+  try {
+    job()
+  } catch (e) {
+    console.warn(e);
+  }
+})()

package/test/contracts/token.js

@@ -0,0 +1,40 @@
+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());