@leofcoin/chain 1.3.3 → 1.3.5

package/src/chain.js

@@ -16,8 +16,10 @@ export default class Chain {
   #blocks = []
   #machine
   #runningEpoch = false
+  #chainSyncing = false
   #lastBlock = {index: 0, hash: '0x0', previousHash: '0x0'}
-
+  #participants = []
+  #participating = false
   #jail = []
 
   constructor() {
@@ -57,14 +59,14 @@ export default class Chain {
     console.log(validators);
     if (!validators[peernet.selectedAccount]?.active) return
 
-    const start = new Date().getTime()
+    const start = Date.now()
     try {
       await this.#createBlock()
-    } catch (e) {
-      console.error(e);
+    } catch (error) {
+      console.error(error);
     }
     
-    const end = new Date().getTime()
+    const end = Date.now()
     console.log(((end - start) / 1000) + ' s');
     
     if (await this.hasTransactionToHandle()) return this.#runEpoch()
@@ -101,7 +103,7 @@ export default class Chain {
       const timeout = setTimeout(() => {
         resolve([{index: 0, hash: '0x0'}])
         debug('sync timed out')
-      }, 10000)
+      }, 10_000)
   
       promises = await Promise.allSettled(promises);
       promises = promises.filter(({status}) => status === 'fulfilled')
@@ -115,11 +117,11 @@ export default class Chain {
     
   }
 
-  sync() {
-    return this.#sync()
+  getLatestBlock() {
+    return this.#getLatestBlock()
   }
 
-  async #sync() {
+  async #getLatestBlock() {
     let promises = [];
     
     let data = await new peernet.protos['peernet-request']({request: 'lastBlock'});
@@ -134,26 +136,27 @@ export default class Chain {
       }
     }
     promises = await this.promiseRequests(promises)
-    promises = promises.reduce((set, value) => {
-      
-      if (value.index > set.index) {
-        set.index = value.index;
-        set.hash = value.hash;
-      }
-      return set
-    }, {index: 0, hash: '0x0'});
-    // get lastblock
-      if (promises.hash && promises.hash !== '0x0') {
-        let localBlock = await peernet.get(promises.hash)
+    let latest = {index: 0, hash: '0x0'}
+
+    for (const value of promises) {      
+      if (value.index > latest.index) {
+        latest.index = value.index;
+        latest.hash = value.hash;
       }
-      
-      
+    }
+    
+    if (latest.hash && latest.hash !== '0x0') {
+      let latestBlock = await peernet.get(latest.hash, block)
+      latestBlock = await new BlockMessage(latestBlock)
+    }
+
+    return latestBlock
   }
 
   async #init() {
     // this.node = await new Node()
-    this.participants = []
-    this.participating = false
+    this.#participants = []
+    this.#participating = false
     const initialized = await contractStore.has(addresses.contractFactory)
     if (!initialized) await this.#setup()
 
@@ -164,7 +167,7 @@ export default class Chain {
       let localBlock
       try {
         localBlock = await chainStore.get('lastBlock')
-      } catch(e) {
+      } catch{
         await chainStore.put('lastBlock', '0x0')
         localBlock = await chainStore.get('lastBlock')
       }
@@ -174,13 +177,11 @@ export default class Chain {
         localBlock = await new BlockMessage(localBlock)
         this.#lastBlock = {...localBlock.decoded, hash: await localBlock.hash}
       } else {
-        await this.#sync()
+        const latestBlock = await this.#getLatestBlock()
+        await this.#syncChain(latestBlock)
       }      
-    } catch (e) {
-      console.log({e});     
-      
-
-      // this.#setup()
+    } catch (error) {
+      console.log({e: error});
     }
 
     await peernet.addRequestHandler('bw-request-message', () => {
@@ -202,9 +203,6 @@ export default class Chain {
     // load local blocks
     await this.resolveBlocks()
     this.#machine = await new Machine(this.#blocks)
-    // for (const block of this.#blocks) {
-    //   block.loaded = true
-    // }
     await this.#loadBlocks(this.#blocks)
     return this
   }
@@ -216,29 +214,33 @@ export default class Chain {
     this.#jail.push(validatorInfo.address)
   }
 
-  async #peerConnected(peer) {
-    let node = await new peernet.protos['peernet-request']({request: 'lastBlock'})
-    node = await peernet.prepareMessage(node)
-    let response = await peer.request(node.encoded)
-    response = await new globalThis.peernet.protos['peernet-response'](response)
-    let lastBlock = response.decoded.response
+  async #syncChain(lastBlock) {
+    if (this.#chainSyncing) return
 
     if (!this.lastBlock || Number(this.lastBlock.index) < Number(lastBlock.index)) {
-         // TODO: check if valid
+      this.#chainSyncing = true
+      // TODO: check if valid
       const localIndex = this.lastBlock ? this.lastBlock.index : 0
       const index = lastBlock.index
       await this.resolveBlock(lastBlock.hash)
-      let blocksSynced = localIndex > 0 ? localIndex > index ? localIndex - index : index - localIndex : index
+      let blocksSynced = localIndex > 0 ? (localIndex > index ? localIndex - index : index - localIndex) : index
       debug(`synced ${blocksSynced} ${blocksSynced > 1 ? 'blocks' : 'block'}`)
 
       const end = this.#blocks.length
-      const start = (this.#blocks.length) - blocksSynced
+      const start = this.#blocks.length - blocksSynced
       await this.#loadBlocks(this.blocks.slice(start))
-      this.#lastBlock = this.#blocks[this.#blocks.length - 1]
-      const message = await new BlockMessage(this.lastBlock)
-      await blockStore.put(await message.hash, message.encoded)
-      await chainStore.put('lastBlock', this.lastBlock.hash)
+      await this.#updateState(this.#blocks[this.#blocks.length - 1])      
+      this.#chainSyncing = false
     }
+  }
+
+  async #peerConnected(peer) {
+    let node = await new peernet.protos['peernet-request']({request: 'lastBlock'})
+    node = await peernet.prepareMessage(node)
+    let response = await peer.request(node.encoded)
+    response = await new globalThis.peernet.protos['peernet-response'](response)
+    let lastBlock = response.decoded.response
+    this.#syncChain(lastBlock)
  }
 
  #epochTimeout
@@ -248,9 +250,9 @@ export default class Chain {
     transaction = await new TransactionMessage(transaction)
     const has = await transactionPoolStore.has(await transaction.hash)
     if (!has) await transactionPoolStore.put(await transaction.hash, transaction.encoded)
-    if (this.participating && !this.#runningEpoch) this.#runEpoch()
-  } catch (e) {
-    throw Error('invalid transaction')
+    if (this.#participating && !this.#runningEpoch) this.#runEpoch()
+  } catch {
+    throw new Error('invalid transaction')
   }
 }
 
@@ -263,7 +265,7 @@ async resolveBlock(hash) {
   let block = await peernet.get(hash, 'block')
   block = await new BlockMessage(block)
   if (!await peernet.has(hash, 'block')) await peernet.put(hash, block.encoded, 'block')
-  const size = block.encoded.length || block.encoded.byteLength
+  const size = block.encoded.length > 0 ? block.encoded.length : block.encoded.byteLength
   block = {...block.decoded, hash}
   if (this.#blocks[block.index] && this.#blocks[block.index].hash !== block.hash) throw `invalid block ${hash} @${block.index}`
   this.#blocks[block.index] = block
@@ -282,7 +284,7 @@ async resolveBlock(hash) {
         await this.resolveBlock(hash)
         this.#lastBlock = this.#blocks[this.#blocks.length - 1]
         
-    } catch (e) {
+    } catch {
       await chainStore.put('lastBlock', new TextEncoder().encode('0x0'))
       return this.resolveBlocks()
 // console.log(e);
@@ -296,8 +298,8 @@ async resolveBlock(hash) {
           try {
             await this.#machine.execute(transaction.to, transaction.method, transaction.params)
 
-          } catch (e) {
-  console.log(e);
+          } catch (error) {
+  console.log(error);
           }
         }
         this.#blocks[block.index].loaded = true
@@ -329,10 +331,10 @@ async resolveBlock(hash) {
       let result = await this.#machine.execute(to, method, params, from, nonce)
       // if (!result) result = this.#machine.state
       pubsub.publish(`transaction.completed.${hash}`, {status: 'fulfilled', hash})
-      return result ? result : 'no state change'
-    } catch (e) {
-      pubsub.publish(`transaction.completed.${hash}`, {status: 'fail', hash, error: e})
-      throw e
+      return result || 'no state change'
+    } catch (error) {
+      pubsub.publish(`transaction.completed.${hash}`, {status: 'fail', hash, error: error})
+      throw error
     }
   }
 
@@ -369,11 +371,15 @@ async resolveBlock(hash) {
       // await transactionStore.put(transaction.hash, transaction.encoded)
       const index = contracts.indexOf(transaction.to)
       if (index === -1) contracts.push(transaction.to)
+      // Todo: go trough all accounts      
       promises.push(this.#executeTransaction(transaction))
+      
     }
     try {
       promises = await Promise.allSettled(promises)
       for (let transaction of blockMessage.decoded.transactions) {
+        pubsub.publish('transaction-processed', transaction)
+        if (transaction.to === peernet.selectedAccount) pubsub.publish('account-transaction-processed', transaction)        
         await accountsStore.put(transaction.from, String(transaction.nonce))
       }
       
@@ -386,8 +392,9 @@ async resolveBlock(hash) {
 
       
       pubsub.publish('block-processed', blockMessage.decoded)
-    } catch (e) {
-      console.log({e});
+      
+    } catch (error) {
+      console.log({e: error});
     }
 
   }
@@ -407,7 +414,7 @@ async resolveBlock(hash) {
     // introduce peer-reputation
     // peerReputation(peerId)
     // {bandwith: {up, down}, uptime}
-    this.participating = true
+    this.#participating = true
     if (!await this.staticCall(addresses.validators, 'has', [address])) await this.createTransactionFrom(address, addresses.validators, 'addValidator', [address])
     if (await this.hasTransactionToHandle() && !this.#runningEpoch) await this.#runEpoch()
     
@@ -469,7 +476,7 @@ async resolveBlock(hash) {
         block.transactions.push(transaction)
         block.fees += Number(calculateFee(transaction))
         await accountsStore.put(transaction.from, new TextEncoder().encode(String(transaction.nonce)))
-      } catch (e) {
+      } catch {
         transaction = await new TransactionMessage(transaction)
         await transactionPoolStore.delete(await transaction.hash)
       }
@@ -502,9 +509,7 @@ async resolveBlock(hash) {
               address: validator,
               bw: bw.up + bw.down
             })
-          } catch(e) {
-
-          }
+          } catch{}
 
         } else if (peernet.selectedAccount === validator) {
           block.validators.push({
@@ -532,17 +537,17 @@ async resolveBlock(hash) {
     else block.index += 1
 
     block.previousHash = this.lastBlock?.hash || '0x0'
-    block.timestamp = new Date().getTime()
+    block.timestamp = Date.now()
 
     const parts = String(block.fees).split('.')
     let decimals = 0
     if (parts[1]) {
       const potentional = parts[1].split('e')
-      if (potentional[0] !== parts[1]) {
-        parts[1] = potentional[0]
-        decimals = Number(potentional[1]?.replace(/\-|\+/g, '')) + Number(potentional[0].length)
-      } else {
+      if (potentional[0] === parts[1]) {
         decimals = parts[1].length
+      } else {
+        parts[1] = potentional[0]
+        decimals = Number(potentional[1]?.replace(/[+-]/g, '')) + Number(potentional[0].length)
       }
 
     }
@@ -562,9 +567,10 @@ async resolveBlock(hash) {
       debug(`created block: ${hash}`)
 
       peernet.publish('add-block', blockMessage.encoded)
-    } catch (e) {
-      console.log(e);
-      throw Error(`invalid block ${block}`)
+      pubsub.publish('add-block', blockMessage.decoded)
+    } catch (error) {
+      console.log(error);
+      throw new Error(`invalid block ${block}`)
     }
     // data = await this.#machine.execute(to, method, params)
     // transactionStore.put(message.hash, message.encoded)
@@ -633,8 +639,8 @@ async resolveBlock(hash) {
    * @param {Array} params - array of paramters to apply to the contract method
    * @param {Number} nonce - total transaction count [optional]
    */
-  async createTransaction(to, method, params, nonce, signature) {
-    return this.createTransactionFrom(peernet.selectedAccount, to, method, params, nonce)
+  async createTransaction(to, method, parameters, nonce, signature) {
+    return this.createTransactionFrom(peernet.selectedAccount, to, method, parameters, nonce)
   }
 
   
@@ -694,8 +700,8 @@ async #signTransaction (transaction, wallet) {
     } else {
       let nonce = await accountsStore.get(transaction.from)
       nonce = new TextDecoder().decode(nonce)
-      if (transaction.nonce < nonce) throw Error(`a transaction with a higher nonce already exists`)
-      if (transaction.nonce === nonce) throw Error(`a transaction with the same nonce already exists`)
+      if (transaction.nonce < nonce) throw new Error(`a transaction with a higher nonce already exists`)
+      if (transaction.nonce === nonce) throw new Error(`a transaction with the same nonce already exists`)
     }
     return transaction
   }
@@ -710,10 +716,10 @@ async #signTransaction (transaction, wallet) {
    * @param {Array} params - array of paramters to apply to the contract method
    * @param {Number} nonce - total transaction count [optional]
    */
-  async createTransactionFrom(from, to, method, params, nonce) {
+  async createTransactionFrom(from, to, method, parameters, nonce) {
     try {
       
-      const rawTransaction = await this.createRawTransaction({from, to, nonce, method, params})    
+      const rawTransaction = await this.createRawTransaction({from, to, nonce, method, params: parameters})    
       const transaction = await this.signTransaction(rawTransaction, from)
       const message = await new TransactionMessage(transaction)
 
@@ -729,7 +735,7 @@ async #signTransaction (transaction, wallet) {
     
             setTimeout(async () => {
               pubsub.unsubscribe(`transaction.completed.${await message.hash}`, completed)
-            }, 10000)
+            }, 10_000)
           }
           pubsub.subscribe(`transaction.completed.${await message.hash}`, completed)
         }
@@ -741,9 +747,9 @@ async #signTransaction (transaction, wallet) {
       peernet.publish('add-transaction', message.encoded)
       this.#addTransaction(message.encoded)
       return {hash: await message.hash, data, fee: await calculateFee(message.decoded), wait}
-    } catch (e) {
-      console.log(e)
-      throw e
+    } catch (error) {
+      console.log(error)
+      throw error
     }
     
   }
@@ -758,20 +764,19 @@ async #signTransaction (transaction, wallet) {
   }
 
   /**
-   *
-   * @param {String} contract - a contract string (see plugins/deployContract)
+   * 
+   * @param {String} contract 
+   * @param {Array} parameters 
+   * @returns 
    */
-  async deployContract(contract, params = []) {
-    globalThis.msg = {sender: peernet.selectedAccount, call: this.call}
-
-    const hash = await this.createContractAddress(creator, contract, params)
-console.log(hash);
+  async deployContract(contract, parameters = []) {
+    const message = await createContractMessage(peernet.selectedAccount, contract, parameters)
     try {
-      const tx = await this.createTransactionFrom(peernet.selectedAccount, addresses.contractFactory, 'deployContract', [hash, creator, contract, constructorParameters])
-    } catch (e) {
-      throw e
+      await this.#machine.addContract(message)  
+    } catch (error) {
+      throw error
     }
-    return this.#machine.addContract(message)
+    return this.createTransactionFrom(peernet.selectedAccount, addresses.contractFactory, 'registerContract', [await message.hash])    
   }
 
   #createMessage(sender = peernet.selectedAccount) {
@@ -784,33 +789,33 @@ console.log(hash);
     }
   }
 
-  internalCall(sender, contract, method, params) {
+  internalCall(sender, contract, method, parameters) {
     globalThis.msg = this.#createMessage(sender)
 
-    return this.#machine.execute(contract, method, params)
+    return this.#machine.execute(contract, method, parameters)
   }
 
-  call(contract, method, params) {
+  call(contract, method, parameters) {
     globalThis.msg = this.#createMessage()
 
-    return this.#machine.execute(contract, method, params)
+    return this.#machine.execute(contract, method, parameters)
   }
 
-  staticCall(contract, method, params) {
+  staticCall(contract, method, parameters) {
     globalThis.msg = this.#createMessage()
-    return this.#machine.get(contract, method, params)
+    return this.#machine.get(contract, method, parameters)
   }
 
-  delegate(contract, method, params) {
+  delegate(contract, method, parameters) {
     globalThis.msg = this.#createMessage()
 
-    return this.#machine.execute(contract, method, params)
+    return this.#machine.execute(contract, method, parameters)
   }
 
-  staticDelegate(contract, method, params) {
+  staticDelegate(contract, method, parameters) {
     globalThis.msg = this.#createMessage()
 
-    return this.#machine.get(contract, method, params)
+    return this.#machine.get(contract, method, parameters)
   }
 
   mint(to, amount) {
@@ -825,6 +830,19 @@ console.log(hash);
     return this.staticCall(addresses.nativeToken, 'balances')
   }
 
+  get contracts() {
+    return this.staticCall(addresses.contractFactory, 'contracts')
+  }
+  /**
+   * 
+   * @param {Address} address old contract address
+   * @param {Address} newAddress new contract address
+   * @returns 
+   */
+  async updateImplementation(address, newAddress) {
+    return this.call(addresses.contractFactory, 'updateImplementation', [address, newAddress])
+  }
+
   deleteAll() {
     return this.#machine.deleteAll()
   }

package/src/contracts/factory.js

@@ -12,17 +12,24 @@ export default class Factory {
    */
   #contracts = []
 
+  /** 
+   * Object => address => Array[addresses]
+   */
+  #implementations = {}
+
   constructor(state) {
     if (state) {
       this.#contracts = state.contracts
       this.#totalContracts = state.totalContracts
+      this.#implementations = state.implementations
     }
   }
 
   get state() {
     return {
       totalContracts: this.#totalContracts,
-      contracts: this.#contracts
+      contracts: this.#contracts,
+      implementations: this.#implementations
     }
   }
 
@@ -37,23 +44,59 @@ export default class Factory {
   get totalContracts() {
     return this.#totalContracts
   }
-
-  isvalid(hash, creator, contract, constructorParameters = []) {
-    const message = new ContractMessage({
-      creator,
-      contract,
-      constructorParameters
-    })
-    return Boolean(message.hash === hash)
+  
+  get implementations() {
+    return {...this.#implementations}
   }
 
-  async deployContract(contractHash, creator, contract, constructorParameters = []) {
-    if (contract.creator !== msg.sender) throw new Error('only a contract creator can deploy a contract')
-    if (await contractStore.has(hash)) throw new Error('duplicate contract')
-    if (!this.isValid(contractHash, creator, contract, constructorParameters)) throw new Error('invalid contract')
+  /**
+   * 
+   * @param {Address} address contract address to register
+   */
+  async registerContract(address) {
+    let isAllowed = false
+    isAllowed = await msg.staticCall(address, 'hasRole', [msg.sender, 'IMPLEMENTATION_MANAGER'])
+    if (!isAllowed) throw new Error('only the implementation manager can update') 
+    if (this.#implementations[address]) throw new Error('already registered')
 
-    await contractStore.put(hash, encoded)
     this.#totalContracts += 1
-    this.#contracts.push(hash)
+    this.#implementations[address] = []
+    this.#implementations[address].push(address)
+    this.#contracts.push(address)
+  }
+
+  /**
+   * updates the current implementation to a new address
+   * 
+   * @param {Address} address the current contract address
+   * @param {Address} newAddress the new contract address
+   */
+  async updateImplementation(address, newAddress) {
+    let isAllowed = false
+    isAllowed = await msg.staticCall(address, 'hasRole', [msg.sender, 'IMPLEMENTATION_MANAGER'])
+    if (!isAllowed) throw new Error('only the implementation manager can update')
+    if (!this.#implementations[address]) throw new Error(`register ${address} before updating to ${newAddress}`)
+
+    this.#implementations[address].push(newAddress)
+  }
+
+  /**
+   * 
+   * @param {Address} address the original contract address
+   * @returns {Address} all implementations of the original contract
+   */
+   getImplementations(address) {
+    return this.#implementations[address]
+  }
+
+  /**
+   * 
+   * @param {Address} address the original contract address
+   * @param {Number} index the index of the implmentation item or undefined (returns the latest implementation when undefined)
+   * @returns {Address} the latest/selected implementation of the original contract
+   */
+  getImplementation(address, index) {
+    index = index || this.#implementations[address].length - 1
+    return this.#implementations[address][index]
   }
 }

package/src/contracts/{nameService.js → name-service.js}

@@ -29,9 +29,7 @@ export default class NameService {
     return {...this.#registry}
   }
 
-  get state() {
-
-  }
+  get state() {}
 
   // TODO: control with contract
   constructor(factoryAddress, currency, validatorAddress, price, state) {
@@ -82,8 +80,8 @@ export default class NameService {
     if (balance < this.#price) throw new Error('price exceeds balance')
     try {
       await msg.call(this.#currency, 'transfer', [msg.sender, this.#owner, this.#price])
-    } catch (e) {
-      throw e
+    } catch (error) {
+      throw error
     }
 
     this.#registry[name] = {

package/src/contracts/{nativeToken.js → native-token.js}

@@ -1,7 +1,7 @@
-import Token from './../standards/token.js'
+import Token from '../standards/token.js'
 
 export default class ArtOnline extends Token {
   constructor(state) {
     super('ArtOnline', 'ART', 18, state)
   }
-}
+}

package/src/contracts/{powerToken.js → power-token.js}

@@ -1,4 +1,4 @@
-import Token from './../standards/token.js'
+import Token from '../standards/token.js'
 
 export default class Power extends Token {
   constructor(state) {

package/src/contracts/proxies/{factoryProxy.js → factory-proxy.js}

@@ -1,4 +1,4 @@
-import Proxy from './../../standards/Proxy.js'
+import Proxy from '../../standards/proxy.js'
 
 export default class FactoryProxy extends Proxy {
   /**

package/src/contracts/proxies/{nameServiceProxy.js → name-service-proxy.js}

@@ -1,4 +1,4 @@
-import Proxy from './../../standards/Proxy.js'
+import Proxy from '../../standards/proxy.js'
 
 export default class NameServiceProxy extends Proxy {
   /**

package/src/contracts/proxies/{nativeTokenProxy.js → native-token-proxy.js}

@@ -1,4 +1,4 @@
-import Proxy from './../../standards/Proxy.js'
+import Proxy from '../../standards/proxy.js'
 
 export default class NativeTokenProxy extends Proxy {
   /**

package/src/contracts/proxies/{validatorsProxy.js → validators-proxy.js}

@@ -1,4 +1,4 @@
-import Proxy from './../../standards/Proxy.js'
+import Proxy from '../../standards/proxy.js'
 
 export default class ValidatorsProxy extends Proxy {
   /**

package/src/contracts/proxies/{votingProxy.js → voting-proxy.js}

@@ -1,4 +1,4 @@
-import Proxy from './../../standards/Proxy.js'
+import Proxy from '../../standards/proxy.js'
 
 export default class VotingProxy extends Proxy {
   /**

package/src/contracts/{proxyManager.js → proxy-manager.js}

@@ -1,4 +1,4 @@
-import ProxyManager from './../standards/proxyManager.js'
+import ProxyManager from '../standards/proxy-manager.js'
 
 export default class ArtOnlineProxyManager extends ProxyManager {
   constructor(state) {