@leofcoin/chain 1.0.4

package/src/contracts/nameService.js

@@ -0,0 +1,108 @@
+export default class NameService {
+  /**
+   * string
+   */
+  #name = 'ArtOnlineNameService'
+  /**
+   * string
+   */
+  #owner
+  /**
+   * number
+   */
+  #price = 0
+  /**
+   * Object => string
+   */
+  #registry = {}
+
+  /**
+   * => string
+   */
+  #currency
+
+  get name() {
+    return this.#name
+  }
+
+  get registry() {
+    return {...this.#registry}
+  }
+
+  get state() {
+
+  }
+
+  // TODO: control with contract
+  constructor(factoryAddress, currency, validatorAddress, price, state) {
+    if (state) {
+      this.#owner = state.owner
+      this.#registry = state.registry
+      this.#currency = state.currency
+      this.#price = state.price
+    } else {
+      this.#owner = msg.sender
+      this.#price = price
+      this.#registry['ArtOnlineContractFactory'] = {
+        owner: msg.sender,
+        address: factoryAddress
+      }
+
+      this.#registry['ArtOnlineToken'] = {
+        owner: msg.sender,
+        address: currency
+      }
+
+      this.#registry['ArtOnlineValidators'] = {
+        owner: msg.sender,
+        address: validatorAddress
+      }
+
+      this.#currency = currency
+    }
+  }
+
+  changeOwner(owner) {
+    if (msg.sender !== this.#owner) throw new Error('no owner')
+    this.#owner = owner
+  }
+
+  changePrice(price) {
+    if (msg.sender !== this.#owner) throw new Error('no owner')
+    this.#price = price
+  }
+
+  changeCurrency(currency) {
+    if (msg.sender !== this.#owner) throw new Error('no owner')
+    this.#currency = currency
+  }
+
+  async purchaseName(name, address) {
+    const balance = await msg.call(this.#currency, 'balanceOf', [msg.sender])
+    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
+    }
+
+    this.#registry[name] = {
+      owner: msg.sender,
+      address
+    }
+  }
+
+  lookup(name) {
+    return this.#registry[name]
+  }
+
+  transferOwnership(name, to) {
+    if (msg.sender !== this.#registry.owner) throw new Error('not a owner')
+    this.#registry[name].owner = to
+  }
+
+  changeAddress(name, address) {
+    if (msg.sender !== this.#registry.owner) throw new Error('not a owner')
+    this.#registry[name].address = address
+  }
+}

package/src/contracts/nativeToken.js

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

package/src/contracts/powerToken.js

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

package/src/contracts/proxies/factoryProxy.js

@@ -0,0 +1,12 @@
+import Proxy from './../../standards/Proxy.js'
+
+export default class FactoryProxy extends Proxy {
+  /**
+   * string
+   */
+  #name = 'ArtOnlineContractFactoryProxy'
+
+  constructor(proxyManager, state) {
+    super(proxyManager, state)
+  }
+}

package/src/contracts/proxies/nameServiceProxy.js

@@ -0,0 +1,12 @@
+import Proxy from './../../standards/Proxy.js'
+
+export default class NameServiceProxy extends Proxy {
+  /**
+   * string
+   */
+  #name = 'ArtOnlineNameServiceProxy'
+
+  constructor(proxyManager, state) {
+    super(proxyManager, state)
+  }
+}

package/src/contracts/proxies/nativeTokenProxy.js

@@ -0,0 +1,12 @@
+import Proxy from './../../standards/Proxy.js'
+
+export default class NativeTokenProxy extends Proxy {
+  /**
+   * string
+   */
+  #name = 'ArtOnlineNativeTokenProxy'
+
+  constructor(proxyManager, state) {
+    super(proxyManager, state)
+  }
+}

package/src/contracts/proxies/validatorsProxy.js

@@ -0,0 +1,12 @@
+import Proxy from './../../standards/Proxy.js'
+
+export default class ValidatorsProxy extends Proxy {
+  /**
+   * string
+   */
+  #name = 'ArtOnlineValidatorsProxy'
+
+  constructor(proxyManager, state) {
+    super(proxyManager, state)
+  }
+}

package/src/contracts/proxies/votingProxy.js

@@ -0,0 +1,12 @@
+import Proxy from './../../standards/Proxy.js'
+
+export default class VotingProxy extends Proxy {
+  /**
+   * string
+   */
+  #name = 'ArtOnlineVotingProxy'
+
+  constructor(proxyManager, state) {
+    super(proxyManager, state)
+  }
+}

package/src/contracts/proxyManager.js

@@ -0,0 +1,7 @@
+import ProxyManager from './../standards/proxyManager.js'
+
+export default class ArtOnlineProxyManager extends ProxyManager {
+  constructor(state) {
+    super('ArtOnlineProxyManager', state)
+  }
+}

package/src/contracts/validators.js

@@ -0,0 +1,119 @@
+export default class Validators {
+  /**
+   * string
+   */
+  #name = 'ArtOnlineValidators'
+  /**
+   * uint
+   */
+  #totalValidators = 0
+  /**
+   * Object => string(address) => Object
+   */
+  #validators = {}
+
+  #owner
+
+  #currency
+
+  #minimumBalance
+
+  get state() {
+    return {
+      owner: this.#owner,
+      minimumBalance: this.#minimumBalance,
+      currency: this.#currency,
+      totalValidators: this.#totalValidators,
+      validators: this.#validators
+    }
+  }
+
+  constructor(tokenAddress, state) {
+    if (state) {
+      this.#owner = state.owner
+      this.#minimumBalance = state.minimumBalance
+      this.#currency = state.currency
+
+      this.#totalValidators = state.totalValidators
+      this.#validators = state.validators
+    } else {
+      this.#owner = msg.sender
+      this.#minimumBalance = 50000
+      this.#currency = tokenAddress
+
+      this.#totalValidators += 1
+      this.#validators[msg.sender] = {
+        firstSeen: new Date().getTime(),
+        active: true
+      }
+    }
+
+  }
+
+  get name() {
+    return this.#name
+  }
+
+  get owner() {
+    return this.#owner
+  }
+
+  get currency() {
+    return this.#currency
+  }
+
+  get validators() {
+    return {...this.#validators}
+  }
+
+  get totalValidators() {
+    return this.#totalValidators
+  }
+
+  get minimumBalance() {
+    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')
+    this.#currency = currency
+  }
+
+  has(validator) {
+    return Boolean(this.#validators[validator] !== undefined)
+  }
+
+  async addValidator(validator) {
+    if (this.has(validator)) throw new Error('already a validator')
+    const balance = await msg.staticCall(this.currency, 'balanceOf', [msg.sender])
+
+    if (balance < this.minimumBalance) throw new Error(`balance to low! got: ${balance} need: ${this.#minimumBalance}`)
+
+    this.#totalValidators += 1
+    this.#validators[validator] = {
+      firstSeen: new Date().getTime(),
+      active: true
+    }
+  }
+
+  removeValidator(validator) {
+    if (!this.has(validator)) throw new Error('validator not found')
+
+    this.#totalValidators -= 1
+    delete this.#validators[validator]
+  }
+
+  async updateValidator(validator, active) {
+    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}`)
+
+    this.#validators[validator].active = active
+  }
+}

package/src/fee/config.js

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

package/src/lib.js

@@ -0,0 +1,67 @@
+import ContractMessage from './messages/contract'
+import TransactionMessage from './messages/transaction'
+import BlockMessage from './messages/block'
+import BWMessage from './messages/bw'
+import BWRequestMessage from './messages/bw-request'
+import bs58 from '@vandeurenglenn/base58'
+import bytecodes from './bytecodes.json'
+import addresses from './addresses.json'
+
+const { contractFactory, nativeToken, nameService, validators } = addresses
+
+const contractFactoryMessage = new Uint8Array(bytecodes.contractFactory.split(','))
+const nativeTokenMessage = new Uint8Array(bytecodes.nativeToken.split(','))
+
+const nameServiceMessage = new Uint8Array(bytecodes.nameService.split(','))
+const validatorsMessage = new Uint8Array(bytecodes.validators.split(','))
+
+const calculateFee = transaction => {
+  // excluded from fees
+  if (transaction.decoded.to === validators) return 0
+  // fee per gb
+  let fee = transaction.encoded.length
+  fee = fee / 1024
+  fee = fee / 1000000
+  const parts = String(fee).split('.')
+  let decimals = 0
+  if (parts[1]) {
+    const potentional = parts[1].split('e')
+    parts[1] = potentional[0]
+    decimals = Number(potentional[1].replace(/\-|\+/g, '')) + Number(potentional[0].length)
+  }
+
+  return Number.parseFloat(fee.toString()).toFixed(decimals)
+}
+
+const calculateTransactionFee = transaction => {
+  transaction = new TransactionMessage(transaction)
+  return calculateFee(transaction)
+}
+
+const calculateReward = (validators, fees) => {
+  validators = Object.keys(validators).reduce((set, key) => {
+    if (validators[key].active) set.push({
+      address: key,
+      reward: 0
+    })
+
+  }, [])
+}
+
+export default {
+  nativeToken,
+  nameService,
+  contractFactory,
+  validators,
+  contractFactoryMessage,
+  nativeTokenMessage,
+  nameServiceMessage,
+  validatorsMessage,
+  TransactionMessage,
+  ContractMessage,
+  BlockMessage,
+  BWMessage,
+  BWRequestMessage,
+  calculateFee,
+  calculateTransactionFee
+}

package/src/machine.js

@@ -0,0 +1,130 @@
+import vm from 'vm'
+import ContractMessage from './messages/contract'
+import TransactionMessage from './messages/transaction'
+import lib from './lib'
+import { info, subinfo } from './utils/utils'
+// import State from './state'
+
+export default class Machine {
+  #contracts = {}
+  #nonces = {}
+  constructor() {
+    return this.#init()
+  }
+
+  #createMessage(sender = peernet.id) {
+    return {
+      sender,
+      call: this.execute,
+      staticCall: this.get.bind(this)
+    }
+  }
+
+  async #init() {
+    // return
+    try {
+      let contracts = [
+        contractStore.get(lib.contractFactory),
+        contractStore.get(lib.nativeToken),
+        contractStore.get(lib.validators),
+        contractStore.get(lib.nameService)
+      ]
+
+      contracts = await Promise.all(contracts)
+      for (const contract of contracts) {
+        const message = new ContractMessage(new Uint8Array(contract.buffer, contract.buffer.byteOffset, contract.buffer.byteLength))
+        await this.#runContract(message)
+      }
+    } catch (e) {
+console.log(e);
+    }
+    // const transactions = await transactionStore.get()
+    // console.log({transactions});
+    // for (const key of Object.keys(transactions)) {
+    //   const message = new TransactionMessage(transactions[key])
+    //   console.log({message});
+    //   const {from, to, method, params} = message.decoded
+    //   globalThis.msg = this.#createMessage(from)
+    //
+    //   console.log({from, to, method, params});
+    //   await this.execute(to, method, params)
+    // }
+    return this
+  }
+
+  async #runContract(contractMessage) {
+    const params = contractMessage.decoded.constructorParameters
+    try {
+
+      const func = new Function(new TextDecoder().decode(contractMessage.decoded.contract))
+      const Contract = func()
+
+      globalThis.msg = this.#createMessage(contractMessage.decoded.creator)
+      // globalThis.msg = {sender: contractMessage.decoded.creator}
+      this.#contracts[contractMessage.hash] = new Contract(...params)
+      info(`loaded contract: ${contractMessage.hash}`);
+      subinfo(`size: ${Math.round((contractMessage.encoded.length / 1024) * 100) / 100} kb`);
+    } catch (e) {
+      console.log(e);
+      console.warn(`removing contract ${contractMessage.hash}`);
+      await contractStore.delete(contractMessage.hash, contractMessage.encoded)
+    }
+  }
+
+  /**
+   * @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')
+  }
+
+  async execute(contract, method, params) {
+    try {
+      let result
+      // don't execute the method on a proxy
+      if (this.#contracts[contract].fallback) {
+        result = this.#contracts[contract].fallback(method, params)
+      } else {
+        result = await this.#contracts[contract][method](...params)
+      }
+
+      // this.#state.put(result)
+      return result
+    } catch (e) {
+      throw e
+    }
+  }
+
+  addJob(contract, method, params, from, nonce) {
+    if (!this.#nonces[from]) this.#nonces[from] = nonce
+    if (nonce === this.#nonces[from] + 1) return this.#contracts[contract][method](...params)
+    // return setTimeout(() => {
+    //   return this.addJob(contract, method, params, from, nonce)
+    // }, 50)
+  }
+
+  get(contract, method, params) {
+    let result
+    if (params?.length > 0) {
+      result = this.#contracts[contract][method](...params)
+    } else {
+      result = this.#contracts[contract][method]
+    }
+    return result
+  }
+
+  async delete(hash) {
+    return contractStore.delete(hash)
+  }
+
+  async deleteAll() {
+    let hashes = await contractStore.get()
+    hashes = Object.keys(hashes).map(hash => this.delete(hash))
+    return Promise.all(hashes)
+  }
+}

package/src/messages/block.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../protos/block.proto.js'
+import CodecFormat from './../../node_modules/@leofcoin/peernet/src/codec/codec-format-interface'
+
+export default class BlockMessage extends CodecFormat {
+  get keys() {
+    return ['index', 'previousHash', 'timestamp', 'reward', 'fees', 'transactions', 'validators']
+  }
+
+  constructor(buffer) {
+    const name = 'block-message'
+    super(buffer, protons(proto).BlockMessage, {name})
+  }
+}

package/src/messages/bw-request.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../protos/bw-request.proto.js'
+import CodecFormat from './../../node_modules/@leofcoin/peernet/src/codec/codec-format-interface'
+
+export default class BWRequestMessage extends CodecFormat {
+  get keys() {
+    return []
+  }
+
+  constructor(buffer) {
+    const name = 'bw-request-message'
+    super(buffer, protons(proto).BWRequestMessage, {name})
+  }
+}

package/src/messages/bw.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../protos/bw.proto.js'
+import CodecFormat from './../../node_modules/@leofcoin/peernet/src/codec/codec-format-interface'
+
+export default class BWMessage extends CodecFormat {
+  get keys() {
+    return ['up', 'down']
+  }
+
+  constructor(buffer) {
+    const name = 'bw-message'
+    super(buffer, protons(proto).BWMessage, {name})
+  }
+}

package/src/messages/contract.js

@@ -0,0 +1,13 @@
+import protons from 'protons'
+import proto from './../protos/contract.proto.js'
+import CodecFormat from './../../node_modules/@leofcoin/peernet/src/codec/codec-format-interface'
+
+export default class ContractMessage extends CodecFormat {
+  get keys() {
+    return ['creator', 'contract', 'constructorParameters']
+  }
+
+  constructor(buffer) {
+    super(buffer, protons(proto).ContractMessage, {name: 'contract-message'})
+  }
+}

package/src/messages/last-block-request.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../protos/last-block-request.proto.js'
+import CodecFormat from './../../node_modules/@leofcoin/peernet/src/codec/codec-format-interface'
+
+export default class LastBlockRequestMessage extends CodecFormat {
+  get keys() {
+    return []
+  }
+
+  constructor(buffer) {
+    const name = 'last-block-request-message'
+    super(buffer, protons(proto).LastBlockRequestMessage, {name})
+  }
+}

package/src/messages/last-block.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../protos/last-block.proto.js'
+import CodecFormat from './../../node_modules/@leofcoin/peernet/src/codec/codec-format-interface'
+
+export default class LastBlockMessage extends CodecFormat {
+  get keys() {
+    return ['hash', 'index']
+  }
+
+  constructor(buffer) {
+    const name = 'last-block-message'
+    super(buffer, protons(proto).LastBlockMessage, {name})
+  }
+}

package/src/messages/transaction.js

@@ -0,0 +1,14 @@
+import protons from 'protons'
+import proto from './../protos/transaction.proto.js'
+import CodecFormat from './../../node_modules/@leofcoin/peernet/src/codec/codec-format-interface'
+
+export default class TransactionMessage extends CodecFormat {
+  get keys() {
+    return ['timestamp', 'from', 'to', 'nonce', 'method', 'params']
+  }
+
+  constructor(buffer) {
+    const name = 'transaction-message'
+    super(buffer, protons(proto).TransactionMessage, {name})
+  }
+}

package/src/node.js

@@ -0,0 +1,55 @@
+// import config from './config/config'
+import Peernet from '@leofcoin/peernet'
+import lib from './lib'
+const { ContractMessage, TransactionMessage, BlockMessage, BWMessage, BWRequestMessage } = lib
+
+export default class Node {
+  constructor() {
+    return this._init()
+  }
+
+  async _init(config = {
+    network: 'leofcoin',
+    root: '.artonline',
+    networkName: 'leofcoin:olivia',
+    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()
+  }
+
+}