nimbus-eth1/nimbus/p2p/clique/clique_utils.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.

##
## Tuoole & Utils for Clique PoA Consensus Protocol
## ================================================
##
## For details see
## `EIP-225 <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
## and
## `go-ethereum <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-225.md>`_
##
## Caveat: Not supporting RLP serialisation encode()/decode()
##

import
  std/[algorithm, strformat, times],
  ../../chain_config,
  ../../config,
  ../../constants,
  ../../db/db_chain,
  ../../errors,
  ../../forks,
  ../../utils,
  ./clique_defs,
  eth/[common, rlp],
  stew/[objects, results],
  stint

type
  EthSortOrder* = enum
    EthDescending = SortOrder.Descending.ord
    EthAscending = SortOrder.Ascending.ord

{.push raises: [Defect].}

# ------------------------------------------------------------------------------
# Private helpers
# ------------------------------------------------------------------------------

proc gasLimitBounds(limit: GasInt): (GasInt, GasInt) =
  ## See also utils.header.gasLimitBounds()
  let
    bndRange = limit div GAS_LIMIT_ADJUSTMENT_FACTOR
    upperBound = if GAS_LIMIT_MAXIMUM - bndRange < limit: GAS_LIMIT_MAXIMUM
                 else: limit + bndRange
    lowerBound = max(GAS_LIMIT_MINIMUM, limit - bndRange)

  return (lowerBound, upperBound)

proc validateGasLimit(header: BlockHeader; limit: GasInt): CliqueResult =
  let (lowBound, highBound) = gasLimitBounds(limit)
  if header.gasLimit < lowBound:
    return err((errCliqueGasLimitTooLow,""))
  if highBound < header.gasLimit:
    return err((errCliqueGasLimitTooHigh,""))
  return ok()

func zeroItem[T](t: typedesc[T]): T {.inline.} =
  discard

# ------------------------------------------------------------------------------
# Public functions
# ------------------------------------------------------------------------------

proc isZero*[T: EthAddress|Hash256|Duration](a: T): bool =
  ## `true` if `a` is all zero
  a == zeroItem(T)

proc sorted*(e: openArray[EthAddress]; order = EthAscending): seq[EthAddress] =
  proc eCmp(x, y: EthAddress): int =
    for n in 0 ..< x.len:
      if x[n] < y[n]:
        return -1
      elif y[n] < x[n]:
        return 1
  e.sorted(cmp = eCmp, order = order.SortOrder)


proc cliqueResultErr*(w: CliqueError): CliqueResult =
  ## Return error result (syntactic sugar)
  err(w)


proc extraDataAddresses*(extraData: Blob): seq[EthAddress] =
  ## Extract signer addresses from extraData header field

  proc toEthAddress(a: openArray[byte]; start: int): EthAddress {.inline.} =
    toArray(EthAddress.len, a[start ..< start + EthAddress.len])

  if EXTRA_VANITY + EXTRA_SEAL < extraData.len and
      ((extraData.len - (EXTRA_VANITY + EXTRA_SEAL)) mod EthAddress.len) == 0:
    var addrOffset = EXTRA_VANITY
    while addrOffset + EthAddress.len <= extraData.len - EXTRA_SEAL:
      result.add extraData.toEthAddress(addrOffset)
      addrOffset += EthAddress.len


proc getBlockHeaderResult*(c: BaseChainDB;
                           number: BlockNumber): Result[BlockHeader,void] {.
                             gcsafe, raises: [Defect,RlpError].} =
  ## Slightly re-phrased dbChain.getBlockHeader(..) command
  var header: BlockHeader
  if c.getBlockHeader(number, header):
    return ok(header)
  err()


# core/types/block.go(343): func (b *Block) WithSeal(header [..]
proc withHeader*(b: EthBlock; header: BlockHeader): EthBlock =
  ## New block with the data from `b` but the header replaced with the
  ## argument one.
  EthBlock(
    header: header,
    txs:    b.txs,
    uncles: b.uncles)

# consensus/misc/forks.go(30): func VerifyForkHashes(config [..]
proc verifyForkHashes*(c: var ChainConfig; header: BlockHeader): CliqueResult {.
                       gcsafe, raises: [Defect,ValueError].} =
  ## Verify that blocks conforming to network hard-forks do have the correct
  ## hashes, to avoid clients going off on different chains.

  # If the homestead reprice hash is set, validate it
  if c.eip150Block.isZero or c.eip150Block != header.blockNumber:
    return ok()

  let hash = header.hash
  if c.eip150Hash.isZero or c.eip150Hash == hash:
    return ok()

  return err((errCliqueGasRepriceFork,
              &"Homestead gas reprice fork: have {c.eip150Hash}, want {hash}"))

proc validateGasLimit*(c: var BaseChainDB; header: BlockHeader): CliqueResult {.
                       gcsafe, raises: [Defect,RlpError,BlockNotFound].} =
  ## See also private function p2p.validate.validateGasLimit()
  let parent = c.getBlockHeader(header.parentHash)
  header.validateGasLimit(parent.gasLimit)

# ------------------------------------------------------------------------------
# Eip 1559 support
# ------------------------------------------------------------------------------

# params/config.go(450): func (c *ChainConfig) IsLondon(num [..]
proc isLondonOrLater*(c: var ChainConfig; number: BlockNumber): bool =
  ## FIXME: London is not defined yet, will come after Berlin
  FkBerlin < c.toFork(number)

proc baseFee*(header: BlockHeader): GasInt =
  # FIXME: `baseFee` header field not defined before `London` fork
  0.GasInt

# consensus/misc/eip1559.go(55): func CalcBaseFee(config [..]
proc calc1599BaseFee*(c: var ChainConfig; parent: BlockHeader): GasInt =
  ## calculates the basefee of the header.

  # If the current block is the first EIP-1559 block, return the
  # initial base fee.
  if not c.isLondonOrLater(parent.blockNumber):
    return EIP1559_INITIAL_BASE_FEE

  let parentGasTarget = parent.gasLimit div EIP1559_ELASTICITY_MULTIPLIER

  # If the parent gasUsed is the same as the target, the baseFee remains
  # unchanged.
  if parent.gasUsed == parentGasTarget:
    return parent.baseFee

  let parentGasDenom = parentGasTarget.i128 *
                         EIP1559_BASE_FEE_CHANGE_DENOMINATOR.i128

  if parentGasTarget < parent.gasUsed:
    # If the parent block used more gas than its target, the baseFee should
    # increase.
    let
      gasUsedDelta = (parent.gasUsed - parentGasTarget).i128
      baseFeeDelta = (parent.baseFee.i128 * gasUsedDelta) div parentGasDenom

    return parent.baseFee + max(baseFeeDelta.truncate(GasInt), 1)

  else:
    # Otherwise if the parent block used less gas than its target, the
    # baseFee should decrease.
    let
      gasUsedDelta = (parentGasTarget - parent.gasUsed).i128
      baseFeeDelta = (parent.baseFee.i128 * gasUsedDelta) div parentGasDenom

    return max(parent.baseFee - baseFeeDelta.truncate(GasInt), 0)


# consensus/misc/eip1559.go(32): func VerifyEip1559Header(config [..]
proc verify1559Header*(c: var ChainConfig;
                       parent, header: BlockHeader): CliqueResult {.
                         gcsafe, raises: [Defect,ValueError].} =
  ## Verify that the gas limit remains within allowed bounds
  let limit = if c.isLondonOrLater(parent.blockNumber):
                parent.gasLimit
              else:
                parent.gasLimit * EIP1559_ELASTICITY_MULTIPLIER
  let rc = header.validateGasLimit(limit)
  if rc.isErr:
    return err(rc.error)

  # Verify the header is not malformed
  if header.baseFee.isZero:
    return err((errCliqueExpectedBaseFee,""))

  # Verify the baseFee is correct based on the parent header.
  var expectedBaseFee = c.calc1599BaseFee(parent)
  if header.baseFee != expectedBaseFee:
    return err((errCliqueBaseFeeError,
                &"invalid baseFee: have {expectedBaseFee}, "&
                &"want {header.baseFee}, " &
                &"parent.baseFee {parent.baseFee}, "&
                &"parent.gasUsed {parent.gasUsed}"))

  return ok()

# clique/clique.go(730): func encodeSigHeader(w [..]
proc encode1559*(header: BlockHeader): seq[byte] =
  ## Encode header field and considering new `baseFee` field for Eip1559.
  var writer = initRlpWriter()
  writer.append(header)
  if not header.baseFee.isZero:
    writer.append(header.baseFee)
  writer.finish

# ------------------------------------------------------------------------------
# Seal hash support
# ------------------------------------------------------------------------------

# clique/clique.go(730): func encodeSigHeader(w [..]
proc encodeSealHeader*(header: BlockHeader): seq[byte] =
  ## Cut sigature off `extraData` header field and consider new `baseFee`
  ## field for Eip1559.
  doAssert EXTRA_SEAL < header.extraData.len

  var rlpHeader = header
  rlpHeader.extraData.setLen(header.extraData.len - EXTRA_SEAL)

  rlpHeader.encode1559

# clique/clique.go(688): func SealHash(header *types.Header) common.Hash {
proc hashSealHeader*(header: BlockHeader): Hash256 =
  ## Returns the hash of a block prior to it being sealed.
  header.encodeSealHeader.keccakHash

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