@leofcoin/chain 1.4.21 → 1.4.23

package/src/chain.ts

@@ -1,710 +0,0 @@
-import { BigNumber, formatUnits, parseUnits, formatBytes } from '@leofcoin/utils'
-import Machine from './machine.js'
-import { ContractMessage, TransactionMessage, BlockMessage, BWMessage, BWRequestMessage } from '@leofcoin/messages'
-import addresses, { nativeToken } from '@leofcoin/addresses'
-import { signTransaction } from '@leofcoin/lib'
-import { contractFactoryMessage, nativeTokenMessage, validatorsMessage, nameServiceMessage, calculateFee } from '@leofcoin/lib'
-import State from './state.js'
-import Contract from './contract.js'
-import { BigNumberish } from '@ethersproject/bignumber'
-
-globalThis.BigNumber = BigNumber
-
-// check if browser or local
-export default class Chain  extends Contract {
-  /** {Address[]} */
-  #validators = []
-  /** {Block[]} */
-  #blocks = []
-
-  #machine
-  /** {Boolean} */
-  #runningEpoch = false
-
-  /** {Boolean} */
-  #chainSyncing = false
-
-  /** {Number} */
-  #totalSize = 0
-
-  /** 
-   * {Block} {index, hash, previousHash}
-   */
-  #lastBlock = {index: 0, hash: '0x0', previousHash: '0x0'}
-
-  /** 
-   * amount the native token has been iteracted with
-   */
-  #nativeCalls = 0
-
-  /** 
-   * amount the native token has been iteracted with
-   */
-   #nativeTransfers = 0
-
-  /** 
-   * amount of native token burned
-   * {Number}
-   */
-  #nativeBurns = 0
-
-  /** 
-   * amount of native tokens minted
-   * {Number}
-   */
-  #nativeMints = 0
-
-  /** 
-   * total amount of transactions
-   * {Number}
-   */
-   #totalTransactions = 0
-
-  #participants = []
-  #participating = false
-  #jail = []
-
-  constructor() {
-    super()
-    return this.#init()
-  }
-
-  get nativeMints() {
-    return this.#nativeMints
-  }
-
-  get nativeBurns() {
-    return this.#nativeBurns
-  }
-  
-  get nativeTransfers() {
-    return this.#nativeTransfers
-  }
-
-  get totalTransactions() {
-    return this.#totalTransactions
-  }
-
-  get nativeCalls() {
-    return this.#nativeCalls
-  }
-
-  get totalSize() {
-    return this.#totalSize
-  }
-
-  get lib() {
-    return lib
-  }
-
-  get lastBlock() {
-    return this.#lastBlock
-  }
-
-  get nativeToken() {
-    return addresses.nativeToken
-  }
-
-  get validators() {
-    return [...this.#validators]
-  }
-
-  get blocks() {
-    return [...this.#blocks]
-  }
-
-  async hasTransactionToHandle() {
-    const size = await transactionPoolStore.size()
-    if (size > 0) return true
-    return false
-  }
-
-  async #runEpoch() {
-    this.#runningEpoch = true
-    console.log('epoch');
-    const validators = await this.staticCall(addresses.validators, 'validators')
-    console.log({validators});
-    if (!validators[globalThis.peernet.selectedAccount]?.active) return
-    const start = Date.now()
-    try {
-      await this.#createBlock()
-    } catch (error) {
-      console.error(error);
-    }
-    
-    const end = Date.now()
-    console.log(((end - start) / 1000) + ' s');
-    
-    if (await this.hasTransactionToHandle()) return this.#runEpoch()
-    this.#runningEpoch = false
-    // if (await this.hasTransactionToHandle() && !this.#runningEpoch) return this.#runEpoch()
-  }
-
-  async #setup() {
-
-    const contracts = [{
-      address: addresses.contractFactory,
-      message: contractFactoryMessage
-    }, {
-      address: addresses.nativeToken,
-      message: nativeTokenMessage
-    }, {
-      address: addresses.validators,
-      message: validatorsMessage
-    }, {
-      address: addresses.nameService,
-      message: nameServiceMessage
-    }]
-
-    await Promise.all(contracts.map(async ({address, message}) => {
-      // console.log({message});
-      message = await new ContractMessage(Uint8Array.from(message.split(',').map(string => Number(string))))
-      await contractStore.put(address, message.encoded)
-    }))
-    console.log('handle native contracts');
-    // handle native contracts
-  }
-
-  promiseRequests(promises) {
-    return new Promise(async (resolve, reject) => {
-      const timeout = setTimeout(() => {
-        resolve([{index: 0, hash: '0x0'}])
-        debug('sync timed out')
-      }, 10_000)
-  
-      promises = await Promise.allSettled(promises);
-      promises = promises.filter(({status}) => status === 'fulfilled')
-      clearTimeout(timeout)
-
-      promises = promises.map(({value}) => new peernet.protos['peernet-response'](value))
-      promises = await Promise.all(promises)
-      promises = promises.map(node => node.decoded.response)      
-      resolve(promises)
-    })
-    
-  }
-
-  getLatestBlock() {
-    return this.#getLatestBlock()
-  }
-
-  async #getLatestBlock() {
-    let promises = [];
-    
-    let data = await new peernet.protos['peernet-request']({request: 'lastBlock'});
-    const node = await peernet.prepareMessage(data);
-
-    for (const peer of peernet.connections) {
-      if (peer.connected && peer.readyState === 'open' && peer.peerId !== this.id) {        
-        promises.push(peer.request(node.encoded));
-      } else if (!peer.connected || peer.readyState !== 'open') {
-        // todo: remove peer
-        // reinitiate channel?
-      }
-    }
-    promises = await this.promiseRequests(promises)
-    let latest = {index: 0, hash: '0x0'}
-
-    for (const value of promises) {      
-      if (value.index > latest.index) {
-        latest.index = value.index;
-        latest.hash = await value.hash();
-      }
-    }
-    
-    if (latest.hash && latest.hash !== '0x0') {
-      latest = await peernet.get(latest.hash, block)
-      latest = await new BlockMessage(latest)
-    }
-
-    return latest
-  }
-
-  async #init() {
-    // this.node = await new Node()
-    this.#participants = []
-    this.#participating = false
-    const initialized = await contractStore.has(addresses.contractFactory)
-    if (!initialized) await this.#setup()
-
-   
-    this.utils = { BigNumber, formatUnits, parseUnits }
-
-    this.state = new State()
-    
-    try {
-      let localBlock
-      try {
-        localBlock = await chainStore.get('lastBlock')
-      } catch{
-        await chainStore.put('lastBlock', '0x0')
-        localBlock = await chainStore.get('lastBlock')
-      }
-      localBlock = new TextDecoder().decode(localBlock)
-      if (localBlock && localBlock !== '0x0') {
-        localBlock = await peernet.get(localBlock, 'block')
-        localBlock = await new BlockMessage(localBlock)
-        this.#lastBlock = {...localBlock.decoded, hash: await localBlock.hash()}
-      } else {
-        const latestBlock = await this.#getLatestBlock()
-        await this.#syncChain(latestBlock)
-      }      
-    } catch (error) {
-      console.log({e: error});
-    }
-
-    await peernet.addRequestHandler('bw-request-message', () => {
-
-      return new BWMessage(peernet.client.bw) || { up: 0, down: 0 }
-    })
-
-    await peernet.addRequestHandler('lastBlock', this.#lastBlockHandler.bind(this))
-
-    peernet.subscribe('add-block', this.#addBlock.bind(this))
-
-    peernet.subscribe('add-transaction', this.#addTransaction.bind(this))
-
-    peernet.subscribe('validator:timeout', this.#validatorTimeout.bind(this))
-
-    pubsub.subscribe('peer:connected', this.#peerConnected.bind(this))
-
-    
-    // load local blocks
-    await this.resolveBlocks()
-    this.#machine = await new Machine(this.#blocks)
-    await this.#loadBlocks(this.#blocks)
-    return this
-  }
-
-  async #validatorTimeout(validatorInfo) {
-    setTimeout(() => {
-      this.#jail.splice(this.jail.indexOf(validatorInfo.address), 1)
-    }, validatorInfo.timeout)
-    this.#jail.push(validatorInfo.address)
-  }
-
-  async #syncChain(lastBlock) {
-    if (this.#chainSyncing || !lastBlock || !lastBlock.hash || !lastBlock.hash) return
-
-    if (!this.lastBlock || Number(this.lastBlock.index) < Number(lastBlock.index)) {
-      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
-      debug(`synced ${blocksSynced} ${blocksSynced > 1 ? 'blocks' : 'block'}`)
-
-      const end = this.#blocks.length
-      const start = (this.#blocks.length - blocksSynced) - 1
-      await this.#loadBlocks(this.blocks.slice(start))
-      await this.#updateState(new BlockMessage(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
-
-
-async #lastBlockHandler() {
-  return new peernet.protos['peernet-response']({response: { hash: this.#lastBlock?.hash, index: this.#lastBlock?.index }})
-}
-
-async resolveBlock(hash) {
-  if (!hash)  throw new Error(`expected hash, got: ${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 > 0 ? block.encoded.length : block.encoded.byteLength
-  this.#totalSize += size
-  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
-  console.log(`resolved block: ${hash} @${block.index} ${formatBytes(size)}`);
-  if (block.previousHash !== '0x0') {
-    return this.resolveBlock(block.previousHash)
-  }
-}
-
-  async resolveBlocks() {
-    try {
-      const localBlock = await chainStore.get('lastBlock')
-      const hash = new TextDecoder().decode(localBlock)
-
-      if (hash && hash !== '0x0')
-        await this.resolveBlock(hash)
-        this.#lastBlock = this.#blocks[this.#blocks.length - 1]
-        
-    } catch {
-      await chainStore.put('lastBlock', new TextEncoder().encode('0x0'))
-      return this.resolveBlocks()
-// console.log(e);
-    }
-  }
-
-  /**
-   * 
-   * @param {Block[]} blocks 
-   */
-  async #loadBlocks(blocks) {
-    for (const block of blocks) {
-      if (block && !block.loaded) {
-        for (const transaction of block.transactions) {
-          try {
-            await this.#machine.execute(transaction.to, transaction.method, transaction.params)
-            if (transaction.to === nativeToken) {
-              this.#nativeCalls += 1
-              if (transaction.method === 'burn') this.#nativeBurns += 1
-              if (transaction.method === 'mint') this.#nativeMints += 1
-              if (transaction.method === 'transfer') this.#nativeTransfers += 1
-            }
-            this.#totalTransactions += 1
-          } catch (error) {
-  console.log(error);
-          }
-        }
-        this.#blocks[block.index].loaded = true
-        debug(`loaded block: ${block.hash} @${block.index}`);
-      }
-    }
-  }
-
-  async #executeTransaction({hash, from, to, method, params, nonce}) {
-    try {
-      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 || 'no state change'
-    } catch (error) {
-      console.log(error);
-      pubsub.publish(`transaction.completed.${hash}`, {status: 'fail', hash, error: error})
-      throw error
-    }
-  }
-
-  async #addBlock(block) {
-    // console.log(block);
-    const blockMessage = await new BlockMessage(block)
-    await Promise.all(blockMessage.decoded.transactions
-      .map(async transaction => transactionPoolStore.delete(transaction.hash)))
-    const hash = await blockMessage.hash()
-    
-    await blockStore.put(hash, blockMessage.encoded)
-    
-    if (this.lastBlock.index < blockMessage.decoded.index) await this.#updateState(blockMessage)
-    debug(`added block: ${hash}`)
-    let promises = []
-    let contracts = []
-    for (let transaction of blockMessage.decoded.transactions) {
-      // 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))
-      }
-      
-      // todo finish state
-      // for (const contract of contracts) {
-      //   const state = await this.#machine.get(contract, 'state')
-      //   // await stateStore.put(contract, state)
-      //   console.log(state);
-      // }
-
-      
-      pubsub.publish('block-processed', blockMessage.decoded)
-      
-    } catch (error) {
-      console.log({e: error});
-    }
-
-  }
-
-  async #updateState(message) {
-    const hash = await message.hash()
-    this.#lastBlock = { hash, ...message.decoded }
-    await this.state.updateState(message)
-    await chainStore.put('lastBlock', hash)
-  }
-
-
-
-  async participate(address) {
-    // TODO: validate participant
-    // hold min amount of 50k ART for 7 days
-    // lock the 50k
-    // introduce peer-reputation
-    // peerReputation(peerId)
-    // {bandwith: {up, down}, uptime}
-    this.#participating = true
-    if (!await this.staticCall(addresses.validators, 'has', [address])) {
-      const rawTransaction = {
-        from: address,
-        to: addresses.validators,
-        method: 'addValidator',
-        params: [address],
-        nonce: (await this.getNonce(address)) + 1,
-        timestamp: Date.now()        
-      }      
-      
-      const transaction = await signTransaction(rawTransaction, peernet.identity)
-      await this.sendTransaction(transaction)
-    }
-    if (await this.hasTransactionToHandle() && !this.#runningEpoch) await this.#runEpoch()
-  }
-
-  // todo filter tx that need to wait on prev nonce
-  async #createBlock(limit = 1800) {
-    // vote for transactions
-    if (await transactionPoolStore.size() === 0) return;
-
-    let transactions = await transactionPoolStore.values(this.transactionLimit)
-    if (Object.keys(transactions)?.length === 0 ) return
-    
-    let block = {
-      transactions: [],
-      validators: [],
-      fees: BigNumber.from(0)
-    }
-
-    // exclude failing tx
-    transactions = await this.promiseTransactions(transactions)
-    transactions = transactions.sort((a, b) => a.nonce - b.nonce)
-    for (let transaction of transactions) { 
-      const hash = await transaction.hash()
-      try {
-        await this.#executeTransaction({...transaction.decoded, hash})
-        block.transactions.push({hash, ...transaction.decoded})
-        block.fees += Number(calculateFee(transaction.decoded))
-        await accountsStore.put(transaction.decoded.from, new TextEncoder().encode(String(transaction.decoded.nonce)))
-      } catch (e) {
-        await transactionPoolStore.delete(hash)
-      }
-    }
-    // don't add empty block
-    if (block.transactions.length === 0) return
-    const validators = await this.staticCall(addresses.validators, 'validators')
-    console.log({validators});
-    // block.validators = Object.keys(block.validators).reduce((set, key) => {
-    //   if (block.validators[key].active) {
-    //     push({
-    //       address: key
-    //     })
-    //   }
-    // }, [])
-    const peers = {}
-    for (const entry of peernet.peerEntries) {
-      peers[entry[0]] = entry[1]
-    }
-    for (const validator of Object.keys(validators)) {
-      if (validators[validator].active) {
-        const peer = peers[validator]
-        if (peer && peer.connected) {
-          let data = await new BWRequestMessage()
-          const node = await peernet.prepareMessage(validator, data.encoded)
-          try {
-            const bw = await peer.request(node.encoded)
-            console.log({bw});
-            block.validators.push({
-              address: validator,
-              bw: bw.up + bw.down
-            })
-          } catch{}
-
-        } else if (peernet.selectedAccount === validator) {
-          block.validators.push({
-            address: peernet.selectedAccount,
-            bw: peernet.bw.up + peernet.bw.down
-          })
-
-          }
-        }
-
-    }
-
-    console.log({validators: block.validators});
-
-    block.reward = 150
-    block.validators = block.validators.map(validator => {
-      validator.reward = String(Number(block.fees) + block.reward / block.validators.length)
-      delete validator.bw
-      return validator
-    })
-    // block.validators = calculateValidatorReward(block.validators, block.fees)
-
-    block.index = this.lastBlock?.index
-    if (block.index === undefined) block.index = 0
-    else block.index += 1
-
-    block.previousHash = this.lastBlock?.hash || '0x0'
-    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]) {
-        decimals = parts[1].length
-      } else {
-        parts[1] = potentional[0]
-        decimals = Number(potentional[1]?.replace(/[+-]/g, '')) + Number(potentional[0].length)
-      }
-
-    }
-    block.fees = Number.parseFloat(String(block.fees)).toFixed(decimals)
-
-    try {
-      await Promise.all(block.transactions
-        .map(async transaction => transactionPoolStore.delete(transaction.hash)))
-
-
-      let blockMessage = await new BlockMessage(block)
-      const hash = await blockMessage.hash()
-      
-      
-      await peernet.put(hash, blockMessage.encoded, 'block')
-      await this.#updateState(blockMessage)
-      debug(`created block: ${hash}`)
-
-      peernet.publish('add-block', blockMessage.encoded)
-      pubsub.publish('add-block', blockMessage.decoded)
-    } catch (error) {
-      throw new Error(`invalid block ${block}`)
-    }
-    // data = await this.#machine.execute(to, method, params)
-    // transactionStore.put(message.hash, message.encoded)
-  }
-
-  
-
-  async #addTransaction(transaction) {
-    try {      
-      transaction = await new TransactionMessage(transaction)
-      const hash = await transaction.hash()
-      const has = await transactionPoolStore.has(hash)
-      if (!has) await transactionPoolStore.put(hash, transaction.encoded)
-      if (this.#participating && !this.#runningEpoch) this.#runEpoch()
-    } catch (e) {
-      console.log(e);
-      throw new Error('invalid transaction')
-    }
-  }
-  /**
-   * every tx done is trough contracts so no need for amount
-   * data is undefined when nothing is returned
-   * error is thrown on error so undefined data doesn't mean there is an error...
-   **/
-   async sendTransaction(transaction) {
-    const event = await super.sendTransaction(transaction)
-    this.#addTransaction(event.message.encoded)
-    return event    
-  }
-
-  /**
-   * 
-   * @param {Address} sender 
-   * @returns {globalMessage}
-   */
-  #createMessage(sender = peernet.selectedAccount) {
-    return {
-      sender,
-      call: this.call,
-      staticCall: this.staticCall,
-      delegate: this.delegate,
-      staticDelegate: this.staticDelegate
-    }
-  }
-
-  /**
-   * 
-   * @param {Address} sender 
-   * @param {Address} contract 
-   * @param {String} method 
-   * @param {Array} parameters 
-   * @returns 
-   */
-  internalCall(sender, contract, method, parameters) {
-    globalThis.msg = this.#createMessage(sender)
-
-    return this.#machine.execute(contract, method, parameters)
-  }
-
-  /**
-   * 
-   * @param {Address} contract 
-   * @param {String} method 
-   * @param {Array} parameters 
-   * @returns 
-   */
-  call(contract, method, parameters) {
-    globalThis.msg = this.#createMessage()
-
-    return this.#machine.execute(contract, method, parameters)
-  }
-
-  staticCall(contract, method, parameters?) {
-    globalThis.msg = this.#createMessage()
-    return this.#machine.get(contract, method, parameters)
-  }
-
-  delegate(contract, method, parameters) {
-    globalThis.msg = this.#createMessage()
-
-    return this.#machine.execute(contract, method, parameters)
-  }
-
-  staticDelegate(contract: Address, method: string, parameters: []): any {
-    globalThis.msg = this.#createMessage()
-
-    return this.#machine.get(contract, method, parameters)
-  }
-
-  mint(to: string, amount: BigNumberish) {
-    return this.call(addresses.nativeToken, 'mint', [to, amount])
-  }
-
-  transfer(from: string, to: string, amount: BigNumberish) {
-    return this.call(addresses.nativeToken, 'transfer', [from, to, amount])
-  }
-
-  get balances(): {address: BigNumberish} {
-    return this.staticCall(addresses.nativeToken, 'balances')
-  }
-
-  get contracts() {
-    return this.staticCall(addresses.contractFactory, 'contracts')
-  }
-
-  deleteAll() {
-    return this.#machine.deleteAll()
-  }
-
-  /**
-   * lookup an address for a registered name using the builtin nameService
-   * @check nameService
-   *
-   * @param {String} - contractName
-   * @returns {String} - address
-   *
-   * @example chain.lookup('myCoolContractName') // qmqsfddfdgfg...
-   */
-  lookup(name): {owner: string, address: string} {
-    return this.call(addresses.nameService, 'lookup', [name])
-  }
-}