nimbus-eth1/nimbus/vm_state_transactions.nim

# Nimbus
# Copyright (c) 2018 Status Research & Development GmbH
# Licensed under either of
#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
#  * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
# at your option. This file may not be copied, modified, or distributed except according to those terms.

import
  ranges/typedranges, sequtils, strformat, tables, options,
  eth/common, chronicles,
  ./constants, ./errors, ./vm/computation,
  ./transaction, ./vm_types, ./vm_state, ./block_types, ./db/[db_chain, state_db], ./utils/header,
  ./vm/interpreter, ./vm/interpreter/gas_costs, ./utils/addresses

proc validateTransaction*(vmState: BaseVMState, transaction: Transaction, sender: EthAddress): bool =
  # XXX: https://github.com/status-im/nimbus/issues/35#issuecomment-391726518
  # XXX: lots of avoidable u256 construction
  var readOnlyDB = vmState.readOnlyStateDB
  let limitAndValue = transaction.gasLimit.u256 + transaction.value
  let gas_cost = transaction.gasLimit.u256 * transaction.gasPrice.u256

  transaction.gasLimit >= transaction.payload.intrinsicGas and
    transaction.gasPrice <= (1 shl 34) and
    limitAndValue <= readOnlyDB.getBalance(sender) and
    transaction.accountNonce == readOnlyDB.getNonce(sender) and
    readOnlyDB.getBalance(sender) >= gas_cost

proc setupComputation*(vmState: BaseVMState, transaction: Transaction, sender: EthAddress, forkOverride=none(Fork)) : BaseComputation =
  let message = newMessage(
      gas = transaction.gasLimit - transaction.payload.intrinsicGas,
      gasPrice = transaction.gasPrice,
      to = transaction.to,
      sender = sender,
      value = transaction.value,
      data = transaction.payload,
      code = vmState.readOnlyStateDB.getCode(transaction.to).toSeq,
      options = newMessageOptions(origin = sender,
                                  createAddress = transaction.to))

  result = newBaseComputation(vmState, vmState.blockNumber, message, forkOverride)
  doAssert result.isOriginComputation

proc execComputation*(computation: var BaseComputation): bool =
  # TODO: use AccountStateDB revert/commit after JournalDB implemented
  let stateDb = computation.vmState.accountDb
  let intermediateRoot = stateDb.rootHash
  computation.vmState.blockHeader.stateRoot = stateDb.rootHash

  try:
    computation.executeOpcodes()
    computation.vmState.mutateStateDB:
      for deletedAccount in computation.getAccountsForDeletion:
        db.deleteAccount deletedAccount

    result = not computation.isError
  except ValueError:
    result = false

  if result:
    stateDb.rootHash = computation.vmState.blockHeader.stateRoot
  else:
    stateDb.rootHash = intermediateRoot

proc applyCreateTransaction*(t: Transaction, vmState: BaseVMState, sender: EthAddress, forkOverride=none(Fork)): UInt256 =
  doAssert t.isContractCreation
  # TODO: clean up params
  trace "Contract creation"

  let fork =
    if forkOverride.isSome:
      forkOverride.get
    else:
      vmState.blockNumber.toFork
  let gasUsed = t.payload.intrinsicGas.GasInt + gasFees[fork][GasTXCreate]

  # TODO: setupComputation refactoring
  let contractAddress = generateAddress(sender, t.accountNonce)
  let msg = newMessage(t.gasLimit - gasUsed, t.gasPrice, t.to, sender, t.value, @[], t.payload,
                       options = newMessageOptions(origin = sender,
                                                   createAddress = contractAddress))

  var c = newBaseComputation(vmState, vmState.blockNumber, msg, forkOverride)

  if execComputation(c):
    var db = vmState.accountDb
    db.addBalance(contractAddress, t.value)

    # XXX: copy/pasted from GST fixture
    # TODO: more merging/refactoring/etc
    # also a couple lines can collapse because variable used once
    # once verified in GST fixture
    let
      gasRemaining = c.gasMeter.gasRemaining.u256
      gasRefunded = c.gasMeter.gasRefunded.u256
      gasUsed2 = t.gasLimit.u256 - gasRemaining
      gasRefund = min(gasRefunded, gasUsed2 div 2)
      gasRefundAmount = (gasRefund + gasRemaining) * t.gasPrice.u256
    #echo "gasRemaining is ", gasRemaining, " and gasRefunded = ", gasRefunded, " and gasUsed2 = ", gasUsed2, " and gasRefund = ", gasRefund, " and gasRefundAmount = ", gasRefundAmount

    var codeCost = 200 * c.output.len

    # This apparently is not supposed to actually consume the gas, just be able to,
    # for purposes of accounting. Py-EVM apparently does consume the gas, but it is
    # not matching observed blockchain balances if consumeGas is called.
    if gasRemaining >= codeCost.u256:
      db.setCode(contractAddress, c.output.toRange)
    else:
      # XXX: Homestead behaves differently; reverts state on gas failure
      # https://github.com/ethereum/py-evm/blob/master/eth/vm/forks/homestead/computation.py
      codeCost = 0
      db.setCode(contractAddress, ByteRange())
    db.addBalance(sender, (t.gasLimit.u256 - gasUsed2 - codeCost.u256)*t.gasPrice.u256)
    return (gasUsed2 + codeCost.u256) * t.gasPrice.u256
  else:
    # FIXME: don't do this revert, but rather only subBalance correctly
    # the if transactionfailed at end is what is supposed to pick it up
    # especially when it's cross-function, it's ugly/fragile
    var db = vmState.accountDb
    db.addBalance(sender, t.value)
    debug "execComputation() error", isError = c.isError
    if c.tracingEnabled:
      c.traceError()
    vmState.clearLogs()
    return t.gasLimit.u256 * t.gasPrice.u256

method executeTransaction(vmState: BaseVMState, transaction: Transaction): (BaseComputation, BlockHeader) {.base.}=
  # Execute the transaction in the vm
  # TODO: introduced here: https://github.com/ethereum/py-evm/commit/21c57f2d56ab91bb62723c3f9ebe291d0b132dde
  # Refactored/Removed here: https://github.com/ethereum/py-evm/commit/cc991bf
  # Deleted here: https://github.com/ethereum/py-evm/commit/746defb6f8e83cee2c352a0ab8690e1281c4227c
  raise newException(ValueError, "Must be implemented by subclasses")


method addTransaction*(vmState: BaseVMState, transaction: Transaction, computation: BaseComputation, b: Block): (Block, Table[string, string]) =
  # Add a transaction to the given block and
  # return `trieData` to store the transaction data in chaindb in VM layer
  # Update the bloomFilter, transaction trie and receipt trie roots, bloom_filter,
  # bloom, and usedGas of the block
  # transaction: the executed transaction
  # computation: the Computation object with executed result
  # block: the Block which the transaction is added in
  # var receipt = vmState.makeReceipt(transaction, computation)
  # vmState.add_receipt(receipt)

  # block.transactions.append(transaction)

  #       # Get trie roots and changed key-values.
  #       tx_root_hash, tx_kv_nodes = make_trie_root_and_nodes(block.transactions)
  #       receipt_root_hash, receipt_kv_nodes = make_trie_root_and_nodes(self.receipts)

  #       trie_data = merge(tx_kv_nodes, receipt_kv_nodes)

  #       block.bloom_filter |= receipt.bloom

  #       block.header.transaction_root = tx_root_hash
  #       block.header.receipt_root = receipt_root_hash
  #       block.header.bloom = int(block.bloom_filter)
  #       block.header.gas_used = receipt.gas_used

  #       return block, trie_data
  result = (b, initTable[string, string]())

method applyTransaction*(
    vmState: BaseVMState,
    transaction: Transaction,
    b: Block,
    isStateless: bool): (BaseComputation, Block, Table[string, string]) =
  # Apply transaction to the given block
  # transaction: the transaction need to be applied
  # b: the block which the transaction applies on
  # isStateless: if isStateless, call vmState.addTransaction to set block

  if isStateless:
    var ourBlock = b # deepcopy
    vmState.blockHeader = b.header
    var (computation, blockHeader) = vmState.executeTransaction(transaction)

    ourBlock.header = blockHeader
    var trieData: Table[string, string]
    (ourBlock, trieData) = vmState.addTransaction(transaction, computation, ourBlock)

    result = (computation, ourBlock, trieData)
  else:
    var (computation, blockHeader) = vmState.executeTransaction(transaction)
    return (computation, nil, initTable[string, string]())