@leofcoin/chain 1.3.3 → 1.3.5

package/src/contracts/validators.js

@@ -1,4 +1,6 @@
-export default class Validators {
+import Roles from './../standards/roles'
+
+export default class Validators extends Roles {
   /**
    * string
    */
@@ -7,43 +9,46 @@ export default class Validators {
    * uint
    */
   #totalValidators = 0
+
+  #activeValidators = 0
   /**
    * Object => string(address) => Object
    */
   #validators = {}
 
-  #owner
-
   #currency
 
   #minimumBalance
 
   get state() {
     return {
-      owner: this.#owner,
+      ...super.state,
       minimumBalance: this.#minimumBalance,
       currency: this.#currency,
       totalValidators: this.#totalValidators,
+      activeValidators: this.#activeValidators,
       validators: this.#validators
     }
   }
 
   constructor(tokenAddress, state) {
+    super(state?.roles)
     if (state) {
-      this.#owner = state.owner
       this.#minimumBalance = state.minimumBalance
       this.#currency = state.currency
 
       this.#totalValidators = state.totalValidators
+      this.#activeValidators = state.activeValidators
       this.#validators = state.validators
     } else {
-      this.#owner = msg.sender
-      this.#minimumBalance = 50000
+      this.#minimumBalance = 50_000
       this.#currency = tokenAddress
 
       this.#totalValidators += 1
+      this.#activeValidators += 1
       this.#validators[msg.sender] = {
-        firstSeen: new Date().getTime(),
+        firstSeen: Date.now(),
+        lastSeen: Date.now(),
         active: true
       }
     }
@@ -54,10 +59,6 @@ export default class Validators {
     return this.#name
   }
 
-  get owner() {
-    return this.#owner
-  }
-
   get currency() {
     return this.#currency
   }
@@ -74,12 +75,8 @@ export default class Validators {
     return this.#minimumBalance
   }
 
-  changeOwner(owner) {
-    if (msg.sender !== this.#owner) throw new Error('not an owner')
-  }
-
   changeCurrency(currency) {
-    if (msg.sender !== this.#owner) throw new Error('not an owner')
+    if (!this.hasRole(msg.sender, 'OWNER')) throw new Error('not an owner')
     this.#currency = currency
   }
 
@@ -87,33 +84,46 @@ export default class Validators {
     return Boolean(this.#validators[validator] !== undefined)
   }
 
+  #isAllowed(address) {
+    if (msg.sender !== address && !this.hasRole(msg.sender, 'OWNER')) throw new Error('sender is not the validator or owner')
+    return true
+  }
+
   async addValidator(validator) {
+    this.#isAllowed(validator)
     if (this.has(validator)) throw new Error('already a validator')
-    const balance = await msg.staticCall(this.currency, 'balanceOf', [msg.sender])
+    
+    const balance = await msg.staticCall(this.currency, 'balanceOf', [validator])
 
     if (balance < this.minimumBalance) throw new Error(`balance to low! got: ${balance} need: ${this.#minimumBalance}`)
 
     this.#totalValidators += 1
+    this.#activeValidators += 1
     this.#validators[validator] = {
-      firstSeen: new Date().getTime(),
+      firstSeen: Date.now(),
+      lastSeen: Date.now(),
       active: true
     }
   }
 
   removeValidator(validator) {
+    this.#isAllowed(validator)
     if (!this.has(validator)) throw new Error('validator not found')
-
+    
     this.#totalValidators -= 1
+    if (this.#validators[validator].active) this.#activeValidators -= 1
     delete this.#validators[validator]
   }
 
   async updateValidator(validator, active) {
+    this.#isAllowed(validator)
     if (!this.has(validator)) throw new Error('validator not found')
-    const balance = await msg.staticCall(this.currency, 'balanceOf', [msg.sender])
-    if (balance < this.minimumBalance && this.#validators[validator].active) this.#validators[validator].active = false
-
-    if (balance < this.minimumBalance) throw new Error(`balance to low! got: ${balance} need: ${this.#minimumBalance}`)
-
+    const balance = await msg.staticCall(this.currency, 'balanceOf', [validator])
+    if (balance < this.minimumBalance && active) throw new Error(`balance to low! got: ${balance} need: ${this.#minimumBalance}`)
+    if (this.#validators[validator].active === active) throw new Error(`already ${active ? 'activated' : 'deactivated'}`)
+    if (active) this.#activeValidators += 1
+    else this.#activeValidators -= 1
+    /** minimum balance always needs to be met */
     this.#validators[validator].active = active
   }
 }

package/src/fee/config.js

@@ -1,3 +1,3 @@
 export default {
-  deployment: 0.000001
+  deployment: 0.000_001
 }

package/src/machine.js

@@ -1,7 +1,7 @@
 import { contractFactory, nativeToken, validators, nameService } from './../../addresses/src/addresses.js'
 import { formatBytes } from './../../utils/src/utils'
-import { randomBytes } from 'crypto'
-import { join } from 'path'
+import { randomBytes } from 'node:crypto'
+import { join } from 'node:path'
 import EasyWorker from '@vandeurenglenn/easy-worker'
 
 // import State from './state'
@@ -25,26 +25,31 @@ export default class Machine {
 
   async #onmessage(data) {
     switch (data.type) {
-      case 'contractError':
+      case 'contractError': {
         console.warn(`removing contract ${await data.hash}`);
         await contractStore.delete(await data.hash)  
       break
+      }
 
-      case 'executionError':
+      case 'executionError': {
         // console.warn(`error executing transaction ${data.message}`);
         pubsub.publish(data.id, {error: data.message})
       break
+      }
 
-      case 'debug':
-        data.messages.forEach(message => debug(message))
+      case 'debug': {
+        for (const message of data.messages) debug(message)
       break
-      case 'machine-ready':
+      }
+      case 'machine-ready': {
         this.lastBlock = data.lastBlock
         pubsub.publish('machine.ready', true)
       break
-      case 'response':
+      }
+      case 'response': {
         pubsub.publish(data.id, data.value)
       break
+      }
     }
     
   }
@@ -80,19 +85,19 @@ export default class Machine {
   }
 
   async #runContract(contractMessage) {
-    const params = contractMessage.decoded.constructorParameters
+    const parameters = contractMessage.decoded.constructorParameters
     try {
 
-      const func = new Function(contractMessage.decoded.contract)
-      const Contract = func()
+      const function_ = new Function(contractMessage.decoded.contract)
+      const Contract = function_()
 
       globalThis.msg = this.#createMessage(contractMessage.decoded.creator)
       // globalThis.msg = {sender: contractMessage.decoded.creator}
-      this.#contracts[await contractMessage.hash] = await new Contract(...params)
+      this.#contracts[await contractMessage.hash] = await new Contract(...parameters)
       debug(`loaded contract: ${await contractMessage.hash}`);
       debug(`size: ${formatBytes(contractMessage.encoded.length)}`);
-    } catch (e) {
-      console.log(e);
+    } catch (error) {
+      console.log(error);
       console.warn(`removing contract ${await contractMessage.hash}`);
       await contractStore.delete(await contractMessage.hash, contractMessage.encoded)
     }
@@ -101,15 +106,14 @@ export default class Machine {
    * @params {ContractMessage} - contractMessage
    */
   async addContract(contractMessage) {
-    if (!await contractStore.has(contractMessage.hash)) {
-      await contractStore.put(contractMessage.hash, contractMessage.encoded)
-      await this.#runContract(contractMessage)
-      return contractMessage.hash
-    }
-    throw new Error('duplicate contract')
+    if (await contractStore.has(await contractMessage.hash)) throw new Error('duplicate contract')
+
+    await contractStore.put(await contractMessage.hash, contractMessage.encoded)
+    await this.#runContract(contractMessage)
+    return contractMessage.hash
   }
 
-  async execute(contract, method, params) {
+  async execute(contract, method, parameters) {
     return new Promise((resolve, reject) => {
       const id = randomBytes(20).toString('hex')
       const message = message => {
@@ -123,22 +127,22 @@ export default class Machine {
         input: {
           contract,
           method,
-          params
+          params: parameters
         }
       })
     })
     
   }
 
-  addJob(contract, method, params, from, nonce) {
+  addJob(contract, method, parameters, from, nonce) {
     if (!this.#nonces[from]) this.#nonces[from] = nonce
-    if (nonce === this.#nonces[from] + 1) return this.#contracts[contract][method](...params)
+    if (nonce === this.#nonces[from] + 1) return this.#contracts[contract][method](...parameters)
     // return setTimeout(() => {
     //   return this.addJob(contract, method, params, from, nonce)
     // }, 50)
   }
 
-  get(contract, method, params) {
+  get(contract, method, parameters) {
     return new Promise((resolve, reject) => {
       const id = randomBytes(20).toString()
       const message = message => {
@@ -151,7 +155,7 @@ export default class Machine {
         input: {
           contract,
           method,
-          params
+          params: parameters
         }
       })
     })

package/src/standards/{Proxy.js → proxy.js}

@@ -6,11 +6,7 @@ export default class Proxy extends Roles {
 
   constructor(proxyManager, state) {
     super(state?.roles)
-    if (state) {
-      this.#proxyManager = state.proxyManager
-    } else {
-      this.#proxyManager = proxyManager
-    }
+    this.#proxyManager = state ? state.proxyManager : proxyManager;
   }
 
   get state() {
@@ -35,8 +31,8 @@ export default class Proxy extends Roles {
     this.#proxyManager = address
   }
 
-  fallback(method, params) {
-    if (msg.sender === this.proxyManager) return this[method](...params)
-    return msg.internalCall(msg.sender, this.#implementation, method, params)
+  fallback(method, parameters) {
+    if (msg.sender === this.proxyManager) return this[method](...parameters)
+    return msg.internalCall(msg.sender, this.#implementation, method, parameters)
   }
 }

package/src/standards/roles.js

@@ -4,6 +4,7 @@ export default class Roles {
    * Object => Array
    */
   #roles = {
+    'IMPLEMENTATION_MANAGER': [],
     'OWNER': [],
     'MINT': [],
     'BURN': []
@@ -12,17 +13,18 @@ export default class Roles {
   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
+    // carefull when including the roles make sure to add the owner
+    // because 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`)
+       throw new TypeError(`expected roles to be an object`)
       }
     } else {
-      // no roles given so default to the msg sender
+      // no roles given so fallback to default to the msg sender
       this.#grantRole(msg.sender, 'OWNER')
+      this.#grantRole(msg.sender, 'IMPLEMENTATION_MANAGER')
     }
   }
 
@@ -35,7 +37,7 @@ export default class Roles {
   }
 
   hasRole(address, role) {
-    return this.#roles[role] ? this.#roles[role].indexOf(address) !== -1 : false
+    return this.#roles[role] ? this.#roles[role].includes(address) : false
   }
 
   #grantRole(address, role) {

package/src/standards/token.js

@@ -81,11 +81,11 @@ export default class Token extends Roles {
     this.#increaseBalance(to, amount)
   }
 
-  burn(to, amount) {
+  burn(from, amount) {
     if (!this.hasRole(msg.sender, 'BURN')) throw new Error('not allowed')
 
     this.#totalSupply = this.#totalSupply.sub(amount)
-    this.#decreaseBalance(to, amount)
+    this.#decreaseBalance(from, amount)
   }
 
   #beforeTransfer(from, to, amount) {

package/src/standards/voting.js

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

package/src/transactions/transaction.js

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

package/src/transactions/validator.js

@@ -19,7 +19,7 @@ export default class Validator {
   async validateTransaction(hash, transaction) {
     delete transaction.hash
     transaction = await create(hasher.hash(transaction))
-    if (transaction !== hash) throw Error('invalid hash')
+    if (transaction !== hash) throw new Error('invalid hash')
     // for (const input of transaction) {
     //   input
     // }

package/src/typer.js

@@ -11,7 +11,7 @@ export default {
   isType: (type, value) => {
     type = type.toLowercase()
     if (type === 'string') return typeof(value) === type
-    if (type === 'number') return !isNaN(Number(value))
+    if (type === 'number') return !Number.isNaN(Number(value))
     if (type === 'address') return isAddress(value)
     if (type === 'BigNumber') return BigNumber.isBigNumber(value)
   },

package/dist/865.browser.js

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