nimbus-eth1/nimbus/p2p/validate.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
  std/[sequtils, sets, tables, times],
  ../constants,
  ../db/[db_chain, accounts_cache],
  ../transaction,
  ../utils,
  ../utils/[difficulty, header],
  ../vm_state,
  ../vm_types,
  ../forks,
  ./dao,
  ../utils/pow,
  ./gaslimit,
  chronicles,
  eth/[common, rlp, trie/trie_defs],
  ethash,
  nimcrypto,
  options,
  stew/[results, endians2]

from stew/byteutils
  import nil

export
  pow.PowRef,
  pow.new,
  results

const
  daoForkBlockExtraData =
    byteutils.hexToByteArray[13](DAOForkBlockExtra).toSeq

{.push raises: [Defect,CatchableError].}

# ------------------------------------------------------------------------------
# Private Helpers
# ------------------------------------------------------------------------------

func isGenesis(header: BlockHeader): bool =
  header.blockNumber == 0.u256 and
    header.parentHash == GENESIS_PARENT_HASH

# ------------------------------------------------------------------------------
# Pivate validator functions
# ------------------------------------------------------------------------------

proc validateSeal(pow: PoWRef; header: BlockHeader): Result[void,string] =
  let (expMixDigest,miningValue) = pow.getPowDigest(header)

  if expMixDigest != header.mixDigest:
    let
      miningHash = header.getPowSpecs.miningHash
      (size, cachedHash) = pow.getPowCacheLookup(header.blockNumber)
    debug "mixHash mismatch",
      actual = header.mixDigest,
      expected = expMixDigest,
      blockNumber = header.blockNumber,
      miningHash = miningHash,
      nonce = header.nonce.toHex,
      difficulty = header.difficulty,
      size = size,
      cachedHash = cachedHash
    return err("mixHash mismatch")

  let value = Uint256.fromBytesBE(miningValue.data)
  if value > Uint256.high div header.difficulty:
    return err("mining difficulty error")

  ok()

proc validateHeader(db: BaseChainDB; header, parentHeader: BlockHeader;
                    numTransactions: int; checkSealOK: bool;
                    pow: PowRef): Result[void,string] =

  template inDAOExtraRange(blockNumber: BlockNumber): bool =
    # EIP-799
    # Blocks with block numbers in the range [1_920_000, 1_920_009]
    # MUST have DAOForkBlockExtra
    let DAOHigh = db.config.daoForkBlock + DAOForkExtraRange.u256
    db.config.daoForkBlock <= blockNumber and
      blockNumber < DAOHigh

  if header.extraData.len > 32:
    return err("BlockHeader.extraData larger than 32 bytes")

  if header.gasUsed == 0 and 0 < numTransactions:
    return err("zero gasUsed but tranactions present");

  if header.gasUsed < 0 or header.gasUsed > header.gasLimit:
    return err("gasUsed should be non negative and smaller or equal gasLimit")

  if header.blockNumber != parentHeader.blockNumber + 1:
    return err("Blocks must be numbered consecutively")

  if header.timestamp.toUnix <= parentHeader.timestamp.toUnix:
    return err("timestamp must be strictly later than parent")

  if db.config.daoForkSupport and inDAOExtraRange(header.blockNumber):
    if header.extraData != daoForkBlockExtraData:
      return err("header extra data should be marked DAO")

  let calcDiffc = db.config.calcDifficulty(header.timestamp, parentHeader)
  if header.difficulty < calcDiffc:
    return err("provided header difficulty is too low")

  if checkSealOK:
    return pow.validateSeal(header)

  result = ok()


func validateUncle(currBlock, uncle, uncleParent: BlockHeader):
                                               Result[void,string] =
  if uncle.blockNumber >= currBlock.blockNumber:
    return err("uncle block number larger than current block number")

  if uncle.blockNumber != uncleParent.blockNumber + 1:
    return err("Uncle number is not one above ancestor's number")

  if uncle.timestamp.toUnix < uncleParent.timestamp.toUnix:
    return err("Uncle timestamp is before ancestor's timestamp")

  if uncle.gasUsed > uncle.gasLimit:
    return err("Uncle's gas usage is above the limit")

  result = ok()


proc validateUncles(chainDB: BaseChainDB; header: BlockHeader;
                    uncles: seq[BlockHeader]; checkSealOK: bool;
                    pow: PowRef): Result[void,string] =
  let hasUncles = uncles.len > 0
  let shouldHaveUncles = header.ommersHash != EMPTY_UNCLE_HASH

  if not hasUncles and not shouldHaveUncles:
    # optimization to avoid loading ancestors from DB, since the block has
    # no uncles
    return ok()
  if hasUncles and not shouldHaveUncles:
    return err("Block has uncles but header suggests uncles should be empty")
  if shouldHaveUncles and not hasUncles:
    return err("Header suggests block should have uncles but block has none")

  # Check for duplicates
  var uncleSet = initHashSet[Hash256]()
  for uncle in uncles:
    let uncleHash = uncle.blockHash
    if uncleHash in uncleSet:
      return err("Block contains duplicate uncles")
    else:
      uncleSet.incl uncleHash

  let recentAncestorHashes = chainDB.getAncestorsHashes(
                               MAX_UNCLE_DEPTH + 1, header)
  let recentUncleHashes = chainDB.getUncleHashes(recentAncestorHashes)
  let blockHash = header.blockHash

  for uncle in uncles:
    let uncleHash = uncle.blockHash

    if uncleHash == blockHash:
      return err("Uncle has same hash as block")

    # ensure the uncle has not already been included.
    if uncleHash in recentUncleHashes:
      return err("Duplicate uncle")

    # ensure that the uncle is not one of the canonical chain blocks.
    if uncleHash in recentAncestorHashes:
      return err("Uncle cannot be an ancestor")

    # ensure that the uncle was built off of one of the canonical chain
    # blocks.
    if (uncle.parentHash notin recentAncestorHashes) or
       (uncle.parentHash == header.parentHash):
      return err("Uncle's parent is not an ancestor")

    # check uncle against own parent
    var parent: BlockHeader
    if not chainDB.getBlockHeader(uncle.parentHash,parent):
      return err("Uncle's parent has gone missing")
    if uncle.timestamp <= parent.timestamp:
      return err("Uncle's parent must me older")

    # Now perform VM level validation of the uncle
    if checkSealOK:
      result = pow.validateSeal(uncle)
      if result.isErr:
        return

    let uncleParent = chainDB.getBlockHeader(uncle.parentHash)
    result = validateUncle(header, uncle, uncleParent)
    if result.isErr:
      return

    result = chainDB.validateGasLimitOrBaseFee(uncle, uncleParent)
    if result.isErr:
      return

  result = ok()

# ------------------------------------------------------------------------------
# Public function, extracted from executor
# ------------------------------------------------------------------------------

proc validateTransaction*(vmState: BaseVMState, tx: Transaction,
                          sender: EthAddress, fork: Fork): bool =
  let balance = vmState.readOnlyStateDB.getBalance(sender)
  let nonce = vmState.readOnlyStateDB.getNonce(sender)

  if tx.txType == TxEip2930 and fork < FkBerlin:
    debug "invalid tx: Eip2930 Tx type detected before Berlin"
    return

  if tx.txType == TxEip1559 and fork < FkLondon:
    debug "invalid tx: Eip1559 Tx type detected before London"
    return

  if vmState.cumulativeGasUsed + tx.gasLimit > vmState.blockHeader.gasLimit:
    debug "invalid tx: block header gasLimit reached",
      maxLimit=vmState.blockHeader.gasLimit,
      gasUsed=vmState.cumulativeGasUsed,
      addition=tx.gasLimit
    return

  # ensure that the user was willing to at least pay the base fee
  let baseFee = vmState.blockHeader.baseFee.truncate(GasInt)
  if tx.maxFee < baseFee:
    debug "invalid tx: maxFee is smaller than baseFee",
      maxFee=tx.maxFee,
      baseFee=baseFee
    return

  # The total must be the larger of the two
  if tx.maxFee < tx.maxPriorityFee:
    debug "invalid tx: maxFee is smaller than maPriorityFee",
      maxFee=tx.maxFee,
      maxPriorityFee=tx.maxPriorityFee
    return

  # the signer must be able to afford the transaction
  let gasCost = if tx.txType >= TxEip1559:
                  tx.gasLimit.u256 * tx.maxFee.u256
                else:
                  tx.gasLimit.u256 * tx.gasPrice.u256

  if gasCost > balance:
    debug "invalid tx: not enough cash for gas",
      available=balance,
      require=gasCost
    return

  if tx.value > balance - gasCost:
    debug "invalid tx: not enough cash to send",
      available=balance,
      availableMinusGas=balance-gasCost,
      require=tx.value
    return

  if tx.gasLimit < tx.intrinsicGas(fork):
    debug "invalid tx: not enough gas to perform calculation",
      available=tx.gasLimit,
      require=tx.intrinsicGas(fork)
    return

  if tx.nonce != nonce:
    debug "invalid tx: account nonce mismatch",
      txNonce=tx.nonce,
      accountNonce=nonce
    return

  result = true

# ------------------------------------------------------------------------------
# Public functions, extracted from test_blockchain_json
# ------------------------------------------------------------------------------

proc validateHeaderAndKinship*(chainDB: BaseChainDB; header: BlockHeader;
            uncles: seq[BlockHeader]; numTransactions: int; checkSealOK: bool;
            pow: PowRef): Result[void,string] =
  if header.isGenesis:
    if header.extraData.len > 32:
      return err("BlockHeader.extraData larger than 32 bytes")
    return ok()

  let parent = chainDB.getBlockHeader(header.parentHash)
  result = chainDB.validateHeader(
    header, parent, numTransactions, checkSealOK, pow)
  if result.isErr:
    return

  if uncles.len > MAX_UNCLES:
    return err("Number of uncles exceed limit.")

  if not chainDB.exists(header.stateRoot):
    return err("`state_root` was not found in the db.")

  result = chainDB.validateUncles(header, uncles, checkSealOK, pow)
  if result.isOk:
    result = chainDB.validateGasLimitOrBaseFee(header, parent)


proc validateHeaderAndKinship*(chainDB: BaseChainDB;
                      header: BlockHeader; body: BlockBody; checkSealOK: bool;
                      pow: PowRef): Result[void,string] =
  chainDB.validateHeaderAndKinship(
    header, body.uncles, body.transactions.len, checkSealOK, pow)


proc validateHeaderAndKinship*(chainDB: BaseChainDB; ethBlock: EthBlock;
        checkSealOK: bool; pow: PowRef): Result[void,string] =
  chainDB.validateHeaderAndKinship(
    ethBlock.header, ethBlock.uncles, ethBlock.txs.len, checkSealOK, pow)

# ------------------------------------------------------------------------------
# End
# ------------------------------------------------------------------------------