nimbus-eth2/beacon_chain/validator_client.nim

# beacon_chain
# Copyright (c) 2018-2020 Status Research & Development GmbH
# Licensed and distributed under either of
#   * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
#   * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
# at your option. This file may not be copied, modified, or distributed except according to those terms.

import
  # Standard library
  os, strutils, json, times,

  # Nimble packages
  stew/shims/[tables, macros],
  chronos, confutils, metrics, json_rpc/[rpcclient, jsonmarshal],
  chronicles,
  blscurve, json_serialization/std/[options, sets, net],

  # Local modules
  spec/[datatypes, digest, crypto, helpers, network],
  conf, time,
  eth2_network, eth2_discovery, validator_pool, beacon_node_types,
  nimbus_binary_common,
  version, ssz/merkleization,
  sync_manager, keystore_management,
  spec/eth2_apis/validator_callsigs_types,
  eth2_json_rpc_serialization

logScope: topics = "vc"

template sourceDir: string = currentSourcePath.rsplit(DirSep, 1)[0]

## Generate client convenience marshalling wrappers from forward declarations
createRpcSigs(RpcClient, sourceDir / "spec" / "eth2_apis" / "validator_callsigs.nim")

type
  ValidatorClient = ref object
    config: ValidatorClientConf
    client: RpcHttpClient
    beaconClock: BeaconClock
    attachedValidators: ValidatorPool
    fork: Fork
    proposalsForEpoch: Table[Slot, ValidatorPubKey]
    attestationsForEpoch: Table[Slot, seq[AttesterDuties]]
    beaconGenesis: BeaconGenesisTuple

proc getValidatorDutiesForEpoch(vc: ValidatorClient, epoch: Epoch) {.gcsafe, async.} =
  let proposals = await vc.client.get_v1_validator_duties_proposer(epoch)
  # update the block proposal duties this VC should do during this epoch
  vc.proposalsForEpoch.clear()
  for curr in proposals:
    if vc.attachedValidators.validators.contains curr.public_key:
      vc.proposalsForEpoch.add(curr.slot, curr.public_key)

  # couldn't use mapIt in ANY shape or form so reverting to raw loops - sorry Sean Parent :|
  var validatorPubkeys: seq[ValidatorPubKey]
  for key in vc.attachedValidators.validators.keys:
    validatorPubkeys.add key
  # update the attestation duties this VC should do during this epoch
  let attestations = await vc.client.post_v1_validator_duties_attester(
    epoch, validatorPubkeys)
  vc.attestationsForEpoch.clear()
  for a in attestations:
    if vc.attestationsForEpoch.hasKeyOrPut(a.slot, @[a]):
      vc.attestationsForEpoch[a.slot].add(a)

  # for now we will get the fork each time we update the validator duties for each epoch
  vc.fork = await vc.client.get_v1_beacon_states_fork("head")

proc onSlotStart(vc: ValidatorClient, lastSlot, scheduledSlot: Slot) {.gcsafe, async.} =

  let
    # The slot we should be at, according to the clock
    beaconTime = vc.beaconClock.now()
    wallSlot = beaconTime.toSlot()

  let
    slot = wallSlot.slot # afterGenesis == true!
    nextSlot = slot + 1

  info "Slot start",
    lastSlot = shortLog(lastSlot),
    scheduledSlot = shortLog(scheduledSlot),
    beaconTime = shortLog(beaconTime),
    portBN = vc.config.rpcPort,
    cat = "scheduling"

  try:
    # at the start of each epoch - request all validator duties
    # TODO perhaps call this not on the first slot of each Epoch but perhaps
    # 1 slot earlier because there are a few back-and-forth requests which
    # could take up time for attesting... Perhaps this should be called more
    # than once per epoch because of forks & other events...
    if slot.isEpoch:
      await getValidatorDutiesForEpoch(vc, slot.compute_epoch_at_slot)

    # check if we have a validator which needs to propose on this slot
    if vc.proposalsForEpoch.contains slot:
      let public_key = vc.proposalsForEpoch[slot]
      let validator = vc.attachedValidators.validators[public_key]

      let randao_reveal = validator.genRandaoReveal(
        vc.fork, vc.beaconGenesis.genesis_validators_root, slot)

      var newBlock = SignedBeaconBlock(
          message: await vc.client.get_v1_validator_blocks(slot, Eth2Digest(), randao_reveal)
        )

      let blockRoot = hash_tree_root(newBlock.message)
      newBlock.signature = await validator.signBlockProposal(
        vc.fork, vc.beaconGenesis.genesis_validators_root, slot, blockRoot)

      discard await vc.client.post_v1_beacon_blocks(newBlock)

    # https://github.com/ethereum/eth2.0-specs/blob/v0.11.1/specs/phase0/validator.md#attesting
    # A validator should create and broadcast the attestation to the associated
    # attestation subnet when either (a) the validator has received a valid
    # block from the expected block proposer for the assigned slot or
    # (b) one-third of the slot has transpired (`SECONDS_PER_SLOT / 3` seconds
    # after the start of slot) -- whichever comes first.
    discard await vc.beaconClock.sleepToSlotOffset(
      seconds(int64(SECONDS_PER_SLOT)) div 3, slot, "Waiting to send attestations")

    # check if we have validators which need to attest on this slot
    if vc.attestationsForEpoch.contains slot:
      for a in vc.attestationsForEpoch[slot]:
        let validator = vc.attachedValidators.validators[a.public_key]

        let ad = await vc.client.get_v1_validator_attestation_data(slot, a.committee_index)

        # TODO I don't like these (u)int64-to-int conversions...
        let attestation = await validator.produceAndSignAttestation(
          ad, a.committee_length.int, a.validator_committee_index.int,
          vc.fork, vc.beaconGenesis.genesis_validators_root)

        discard await vc.client.post_v1_beacon_pool_attestations(attestation)

  except CatchableError as err:
    error "Caught an unexpected error", err = err.msg

  let
    nextSlotStart = saturate(vc.beaconClock.fromNow(nextSlot))

  info "Slot end",
    slot = shortLog(slot),
    nextSlot = shortLog(nextSlot),
    portBN = vc.config.rpcPort,
    cat = "scheduling"

  when declared(GC_fullCollect):
    # The slots in the validator client work as frames in a game: we want to make
    # sure that we're ready for the next one and don't get stuck in lengthy
    # garbage collection tasks when time is of essence in the middle of a slot -
    # while this does not guarantee that we'll never collect during a slot, it
    # makes sure that all the scratch space we used during slot tasks (logging,
    # temporary buffers etc) gets recycled for the next slot that is likely to
    # need similar amounts of memory.
    GC_fullCollect()

  addTimer(nextSlotStart) do (p: pointer):
    asyncCheck vc.onSlotStart(slot, nextSlot)

programMain:
  let config = makeBannerAndConfig("Nimbus validator client v" & fullVersionStr, ValidatorClientConf)

  setupMainProc(config.logLevel)

  # TODO figure out how to re-enable this without the VCs continuing
  # to run when `make eth2_network_simulation` is killed with CTRL+C
  #ctrlCHandling: discard

  case config.cmd
  of VCNoCommand:
    debug "Launching validator client",
          version = fullVersionStr,
          cmdParams = commandLineParams(),
          config

    var vc = ValidatorClient(
      config: config,
      client: newRpcHttpClient(),
      attachedValidators: ValidatorPool.init()
    )
    vc.proposalsForEpoch.init()
    vc.attestationsForEpoch.init()

    # load all the validators from the data dir into memory
    for curr in vc.config.validatorKeys:
      vc.attachedValidators.addLocalValidator(curr.toPubKey, curr)

    # TODO perhaps we should handle the case if the BN is down and try to connect to it
    # untill success, and also later on disconnets we should continue trying to reconnect
    waitFor vc.client.connect("localhost", Port(config.rpcPort)) # TODO: use config.rpcAddress
    info "Connected to beacon node", port = config.rpcPort

    # init the beacon clock
    vc.beaconGenesis = waitFor vc.client.get_v1_beacon_genesis()
    vc.beaconClock = BeaconClock.init(vc.beaconGenesis.genesis_time)

    let
      curSlot = vc.beaconClock.now().slotOrZero()
      nextSlot = curSlot + 1 # No earlier than GENESIS_SLOT + 1
      fromNow = saturate(vc.beaconClock.fromNow(nextSlot))

    # onSlotStart() requests the validator duties only on the start of each epoch
    # so we should request the duties here when the VC binary boots up in order
    # to handle the case when in the middle of an epoch. Also for the genesis slot.
    waitFor vc.getValidatorDutiesForEpoch(curSlot.compute_epoch_at_slot)

    info "Scheduling first slot action",
      beaconTime = shortLog(vc.beaconClock.now()),
      nextSlot = shortLog(nextSlot),
      fromNow = shortLog(fromNow),
      cat = "scheduling"

    addTimer(fromNow) do (p: pointer) {.gcsafe.}:
      asyncCheck vc.onSlotStart(curSlot, nextSlot)

    runForever()