serve libp2p protocol for light client sync

This extends the `--serve-light-client-data` launch option to serve
locally collected light client data via libp2p.
Backfill of historic best `LightClientUpdate` is not yet implemented.
See ethereum/consensus-specs#2802

To test, in `conf.nim` change `serveLightClientData`'s, and optionally,
`importHistoricLightClientData`'s `defaultValue` to `true`, then run:
```
scripts/launch_local_testnet.sh --kill-old-processes --preset minimal \
    --nodes 4 --disable-htop --stop-at-epoch 7
```
The log files of the beacon nodes will be in the `local_testnet_data`
directory. They are named `log0.txt` through `log3.txt`. The logs can be
browsed for light client related messages.

beacon_chain/gossip_processing/eth2_processor.nim

@@ -58,6 +58,10 @@ declareCounter beacon_sync_committee_contributions_received,
   "Number of valid sync committee contributions processed by this node"
 declareCounter beacon_sync_committee_contributions_dropped,
   "Number of invalid sync committee contributions dropped by this node", labels = ["reason"]
+declareCounter beacon_optimistic_light_client_updates_received,
+  "Number of valid optimistic light client updates processed by this node"
+declareCounter beacon_optimistic_light_client_updates_dropped,
+  "Number of invalid optimistic light client updates dropped by this node", labels = ["reason"]
 
 const delayBuckets = [2.0, 4.0, 6.0, 8.0, 10.0, 12.0, 14.0, Inf]
 
@@ -529,3 +533,23 @@ proc contributionValidator*(
     beacon_sync_committee_contributions_dropped.inc(1, [$v.error[0]])
 
     err(v.error())
+
+proc optimisticLightClientUpdateValidator*(
+    self: var Eth2Processor, src: MsgSource,
+    optimistic_update: OptimisticLightClientUpdate
+): Result[void, ValidationError] =
+  logScope:
+    optimistic_update
+
+  debug "Optimistic light client update received"
+
+  let v = self.dag.validateOptimisticLightClientUpdate(optimistic_update)
+  if v.isOk():
+    trace "Optimistic light client update validated"
+
+    beacon_optimistic_light_client_updates_received.inc()
+  else:
+    debug "Dropping optimistic light client update", error = v.error
+    beacon_optimistic_light_client_updates_dropped.inc(1, [$v.error[0]])
+
+  v

beacon_chain/gossip_processing/gossip_validation.nim

@@ -1003,3 +1003,20 @@ proc validateContribution*(
     sig.get()
 
   return ok((sig, participants))
+
+# https://github.com/ethereum/consensus-specs/blob/v1.1.9/specs/altair/sync-protocol.md#optimistic_light_client_update
+proc validateOptimisticLightClientUpdate*(
+    dag: ChainDAGRef, optimistic_update: OptimisticLightClientUpdate):
+    Result[void, ValidationError] =
+  template latest_local_update(): auto = dag.optimisticLightClientUpdate
+
+  if optimistic_update != latest_local_update:
+    # [IGNORE] The optimistic update is not attesting to the latest block's
+    # parent block.
+    if optimistic_update.attested_header != latest_local_update.attested_header:
+      return errIgnore("OptimisticLightClientUpdate: different attested block")
+
+    # [REJECT] The optimistic update does not match the expected value.
+    return errReject("OptimisticLightClientUpdate: update does not match block")
+
+  ok()

beacon_chain/networking/eth2_network.nim

@@ -158,6 +158,7 @@ type
     Success
     InvalidRequest
     ServerError
+    ResourceUnavailable
 
   PeerStateInitializer* = proc(peer: Peer): RootRef {.gcsafe, raises: [Defect].}
   NetworkStateInitializer* = proc(network: EthereumNode): RootRef {.gcsafe, raises: [Defect].}
@@ -206,6 +207,8 @@ type
 
   InvalidInputsError* = object of CatchableError
 
+  ResourceUnavailableError* = object of CatchableError
+
   NetRes*[T] = Result[T, Eth2NetworkingError]
     ## This is type returned from all network requests
 
@@ -720,6 +723,13 @@ proc handleIncomingStream(network: Eth2Node,
     template returnInvalidRequest(msg: string) =
       returnInvalidRequest(ErrorMsg msg.toBytes)
 
+    template returnResourceUnavailable(msg: ErrorMsg) =
+      await sendErrorResponse(peer, conn, ResourceUnavailable, msg)
+      return
+
+    template returnResourceUnavailable(msg: string) =
+      returnResourceUnavailable(ErrorMsg msg.toBytes)
+
     let s = when useNativeSnappy:
       let fs = libp2pInput(conn)
 
@@ -784,8 +794,8 @@ proc handleIncomingStream(network: Eth2Node,
       await callUserHandler(MsgType, peer, conn, msg.get)
     except InvalidInputsError as err:
       returnInvalidRequest err.msg
-      await sendErrorResponse(peer, conn, ServerError,
-                              ErrorMsg err.msg.toBytes)
+    except ResourceUnavailableError as err:
+      returnResourceUnavailable err.msg
     except CatchableError as err:
       await sendErrorResponse(peer, conn, ServerError,
                               ErrorMsg err.msg.toBytes)
@@ -2239,3 +2249,17 @@ proc broadcastSignedContributionAndProof*(
     node: Eth2Node, msg: SignedContributionAndProof) =
   let topic = getSyncCommitteeContributionAndProofTopic(node.forkDigests.altair)
   node.broadcast(topic, msg)
+
+proc broadcastOptimisticLightClientUpdate*(
+    node: Eth2Node, msg: OptimisticLightClientUpdate) =
+  let
+    forkDigest =
+      if msg.fork_version == node.cfg.SHARDING_FORK_VERSION:
+        node.forkDigests.sharding
+      elif msg.fork_version == node.cfg.BELLATRIX_FORK_VERSION:
+        node.forkDigests.bellatrix
+      else:
+        doAssert msg.fork_version == node.cfg.ALTAIR_FORK_VERSION
+        node.forkDigests.altair
+    topic = getOptimisticLightClientUpdateTopic(forkDigest)
+  node.broadcast(topic, msg)

beacon_chain/networking/faststreams_backend.nim

@@ -1,5 +1,5 @@
 # beacon_chain
-# Copyright (c) 2018-2021 Status Research & Development GmbH
+# Copyright (c) 2018-2022 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).
@@ -112,7 +112,7 @@ proc readResponseChunk(s: AsyncInputStream,
 
   let responseCode = ResponseCode responseCodeByte
   case responseCode:
-  of InvalidRequest, ServerError:
+  of InvalidRequest, ServerError, ResourceUnavailable:
     let errorMsgChunk = await readChunkPayload(s, noSnappy, string)
     let errorMsg = if errorMsgChunk.isOk: errorMsgChunk.value
                    else: return err(errorMsgChunk.error)

beacon_chain/networking/libp2p_streams_backend.nim

@@ -1,5 +1,5 @@
 # beacon_chain
-# Copyright (c) 2018-2021 Status Research & Development GmbH
+# Copyright (c) 2018-2022 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).
@@ -148,7 +148,7 @@ proc readResponseChunk(conn: Connection, peer: Peer,
 
     let responseCode = ResponseCode responseCodeByte
     case responseCode:
-    of InvalidRequest, ServerError:
+    of InvalidRequest, ServerError, ResourceUnavailable:
       let errorMsgChunk = await readChunkPayload(conn, peer, ErrorMsg)
       let errorMsg = if errorMsgChunk.isOk: errorMsgChunk.value
                      else: return err(errorMsgChunk.error)

beacon_chain/nimbus_beacon_node.nim

@@ -755,6 +755,10 @@ proc addAltairMessageHandlers(node: BeaconNode, forkDigest: ForkDigest, slot: Sl
 
   node.network.updateSyncnetsMetadata(currentSyncCommitteeSubnets)
 
+  if node.config.serveLightClientData:
+    node.network.subscribe(
+      getOptimisticLightClientUpdateTopic(forkDigest), basicParams)
+
 proc removeAltairMessageHandlers(node: BeaconNode, forkDigest: ForkDigest) =
   node.removePhase0MessageHandlers(forkDigest)
 
@@ -766,6 +770,9 @@ proc removeAltairMessageHandlers(node: BeaconNode, forkDigest: ForkDigest) =
   node.network.unsubscribe(
     getSyncCommitteeContributionAndProofTopic(forkDigest))
 
+  if node.config.serveLightClientData:
+    node.network.unsubscribe(getOptimisticLightClientUpdateTopic(forkDigest))
+
 proc trackCurrentSyncCommitteeTopics(node: BeaconNode, slot: Slot) =
   # Unlike trackNextSyncCommitteeTopics, just snap to the currently correct
   # set of subscriptions, and use current_sync_committee. Furthermore, this
@@ -1256,6 +1263,18 @@ proc installMessageValidators(node: BeaconNode) =
   installSyncCommitteeeValidators(node.dag.forkDigests.altair)
   installSyncCommitteeeValidators(node.dag.forkDigests.bellatrix)
 
+  if node.config.serveLightClientData:
+    template installOptimisticLightClientUpdateValidator(digest: auto) =
+      node.network.addValidator(
+        getOptimisticLightClientUpdateTopic(digest),
+        proc(msg: OptimisticLightClientUpdate): ValidationResult =
+          toValidationResult(
+            node.processor[].optimisticLightClientUpdateValidator(
+              MsgSource.gossip, msg)))
+
+    installOptimisticLightClientUpdateValidator(node.dag.forkDigests.altair)
+    installOptimisticLightClientUpdateValidator(node.dag.forkDigests.bellatrix)
+
 proc stop(node: BeaconNode) =
   bnStatus = BeaconNodeStatus.Stopping
   notice "Graceful shutdown"

beacon_chain/spec/beacon_time.nim

@@ -146,6 +146,9 @@ const
   # https://github.com/ethereum/consensus-specs/blob/v1.1.9/specs/altair/validator.md#broadcast-sync-committee-contribution
   syncContributionSlotOffset* = TimeDiff(nanoseconds:
     NANOSECONDS_PER_SLOT.int64  * 2 div INTERVALS_PER_SLOT)
+  # https://github.com/ethereum/consensus-specs/blob/v1.1.9/specs/altair/sync-protocol.md#block-proposal
+  optimisticLightClientUpdateSlotOffset* = TimeDiff(nanoseconds:
+    NANOSECONDS_PER_SLOT.int64 div INTERVALS_PER_SLOT)
 
 func toFloatSeconds*(t: TimeDiff): float =
   float(t.nanoseconds) / 1_000_000_000.0
@@ -167,6 +170,8 @@ func sync_committee_message_deadline*(s: Slot): BeaconTime =
   s.start_beacon_time + syncCommitteeMessageSlotOffset
 func sync_contribution_deadline*(s: Slot): BeaconTime =
   s.start_beacon_time + syncContributionSlotOffset
+func optimistic_light_client_update_deadline*(s: Slot): BeaconTime =
+  s.start_beacon_time + optimisticLightClientUpdateSlotOffset
 
 func slotOrZero*(time: BeaconTime): Slot =
   let exSlot = time.toSlot

beacon_chain/spec/datatypes/altair.nim

@@ -614,6 +614,15 @@ func shortLog*(v: LightClientUpdate): auto =
 
 chronicles.formatIt LightClientUpdate: it.shortLog
 
+func shortLog*(v: OptimisticLightClientUpdate): auto =
+  (
+    attested_header: shortLog(v.attested_header),
+    num_active_participants: countOnes(v.sync_aggregate.sync_committee_bits),
+    is_signed_by_next: v.is_signed_by_next_sync_committee
+  )
+
+chronicles.formatIt OptimisticLightClientUpdate: it.shortLog
+
 func clear*(info: var EpochInfo) =
   info.validators.setLen(0)
   info.balances = UnslashedParticipatingBalances()

beacon_chain/spec/network.nim

@@ -94,6 +94,11 @@ func getSyncCommitteeContributionAndProofTopic*(forkDigest: ForkDigest): string
   ## For subscribing and unsubscribing to/from a subnet.
   eth2Prefix(forkDigest) & "sync_committee_contribution_and_proof/ssz_snappy"
 
+# https://github.com/ethereum/consensus-specs/blob/v1.1.9/specs/altair/sync-protocol.md#optimistic_light_client_update
+func getOptimisticLightClientUpdateTopic*(forkDigest: ForkDigest): string =
+  ## For broadcasting the latest `OptimisticLightClientUpdate` to light clients.
+  eth2Prefix(forkDigest) & "optimistic_light_client_update/ssz_snappy"
+
 func getENRForkID*(cfg: RuntimeConfig,
                    epoch: Epoch,
                    genesis_validators_root: Eth2Digest): ENRForkID =

beacon_chain/spec/ssz_codec.nim

@@ -1,5 +1,5 @@
 # beacon_chain
-# Copyright (c) 2018-2021 Status Research & Development GmbH
+# Copyright (c) 2018-2022 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).
@@ -17,7 +17,7 @@ export codec, base, typetraits
 
 # Coding and decoding of SSZ to spec-specific types
 
-template toSszType*(v: Slot|Epoch): auto = uint64(v)
+template toSszType*(v: Slot|Epoch|SyncCommitteePeriod): auto = uint64(v)
 template toSszType*(v: BlsCurveType): auto = toRaw(v)
 template toSszType*(v: ForkDigest|GraffitiBytes): auto = distinctBase(v)
 template toSszType*(v: Version): auto = distinctBase(v)
@@ -34,6 +34,9 @@ template fromSszBytes*(T: type Slot, bytes: openArray[byte]): T =
 template fromSszBytes*(T: type Epoch, bytes: openArray[byte]): T =
   T fromSszBytes(uint64, bytes)
 
+template fromSszBytes*(T: type SyncCommitteePeriod, bytes: openArray[byte]): T =
+  T fromSszBytes(uint64, bytes)
+
 func fromSszBytes*(T: type ForkDigest, bytes: openArray[byte]): T {.raisesssz.} =
   if bytes.len != sizeof(result):
     raiseIncorrectSize T

beacon_chain/sync/sync_protocol.nim

@@ -21,10 +21,15 @@ logScope:
 
 const
   MAX_REQUEST_BLOCKS = 1024
+  MAX_REQUEST_LIGHT_CLIENT_UPDATES = 128
 
   blockByRootLookupCost = allowedOpsPerSecondCost(50)
   blockResponseCost = allowedOpsPerSecondCost(100)
   blockByRangeLookupCost = allowedOpsPerSecondCost(20)
+  lightClientUpdateResponseCost = allowedOpsPerSecondCost(100)
+  lightClientUpdateByRangeLookupCost = allowedOpsPerSecondCost(20)
+  lightClientBootstrapLookupCost = allowedOpsPerSecondCost(5)
+  lightClientBootstrapResponseCost = allowedOpsPerSecondCost(100)
 
 type
   StatusMsg* = object
@@ -439,6 +444,114 @@ p2pProtocol BeaconSync(version = 1,
     debug "Block root request done",
       peer, roots = blockRoots.len, count, found
 
+  proc bestLightClientUpdatesByRange(
+      peer: Peer,
+      startPeriod: SyncCommitteePeriod,
+      reqCount: uint64,
+      reqStep: uint64,
+      response: MultipleChunksResponse[altair.LightClientUpdate])
+      {.async, libp2pProtocol("best_light_client_updates_by_range", 1).} =
+    trace "Received `BestLightClientUpdatesByRange` request",
+      peer, startPeriod, reqCount, reqStep
+    if reqCount == 0'u64 or reqStep == 0'u64:
+      raise newException(InvalidInputsError, "Empty range requested")
+    let dag = peer.networkState.dag
+    if not dag.createLightClientData:
+      raise newException(ResourceUnavailableError, "Request not supported")
+
+    let
+      headPeriod = dag.head.slot.sync_committee_period
+      # Limit number of updates in response
+      count =
+        if startPeriod < headPeriod:
+          0'u64
+        else:
+          min(reqCount,
+            min(1 + (headPeriod - startPeriod) div reqStep,
+              MAX_REQUEST_LIGHT_CLIENT_UPDATES))
+      onePastPeriod = startPeriod + reqStep * count
+
+    peer.updateRequestQuota(count.float * lightClientUpdateByRangeLookupCost)
+    peer.awaitNonNegativeRequestQuota()
+
+    var found = 0
+    for period in startPeriod..<onePastPeriod:
+      let update = dag.getBestLightClientUpdateForPeriod(period)
+      if update.isSome:
+        await response.write(update.get)
+        inc found
+
+    peer.updateRequestQuota(found.float * lightClientUpdateResponseCost)
+
+    debug "`BestLightClientUpdatesByRange` request done",
+      peer, startPeriod, count, reqStep, found
+
+    if found == 0 and count > 0:
+      raise newException(ResourceUnavailableError,
+                         "No `LightClientUpdate` available")
+
+  proc latestLightClientUpdate(
+      peer: Peer,
+      response: SingleChunkResponse[altair.LightClientUpdate])
+      {.async, libp2pProtocol("latest_light_client_update", 1).} =
+    trace "Received `GetLatestLightClientUpdate` request", peer
+    let dag = peer.networkState.dag
+    if not dag.createLightClientData:
+      raise newException(ResourceUnavailableError, "Request not supported")
+
+    peer.awaitNonNegativeRequestQuota()
+
+    let update = dag.getLatestLightClientUpdate
+    if update.isSome:
+      await response.send(update.get)
+    else:
+      raise newException(ResourceUnavailableError,
+                         "No `LightClientUpdate` available")
+
+    peer.updateRequestQuota(lightClientUpdateResponseCost)
+
+  proc optimisticLightClientUpdate(
+      peer: Peer,
+      response: SingleChunkResponse[OptimisticLightClientUpdate])
+      {.async, libp2pProtocol("optimistic_light_client_update", 1).} =
+    trace "Received `GetOptimisticLightClientUpdate` request", peer
+    let dag = peer.networkState.dag
+    if not dag.createLightClientData:
+      raise newException(ResourceUnavailableError, "Request not supported")
+
+    peer.awaitNonNegativeRequestQuota()
+
+    let optimistic_update = dag.getOptimisticLightClientUpdate
+    if optimistic_update.isSome:
+      await response.send(optimistic_update.get)
+    else:
+      raise newException(ResourceUnavailableError,
+                         "No `OptimisticLightClientUpdate` available")
+
+    peer.updateRequestQuota(lightClientUpdateResponseCost)
+
+  proc lightClientBootstrap(
+      peer: Peer,
+      blockRoot: Eth2Digest,
+      response: SingleChunkResponse[altair.LightClientBootstrap])
+      {.async, libp2pProtocol("light_client_bootstrap", 1).} =
+    trace "Received `GetLightClientBootstrap` request", peer, blockRoot
+    let dag = peer.networkState.dag
+    if not dag.createLightClientData:
+      raise newException(ResourceUnavailableError, "Request not supported")
+
+    peer.updateRequestQuota(lightClientBootstrapLookupCost)
+    peer.awaitNonNegativeRequestQuota()
+
+    let bootstrap = dag.getLightClientBootstrap(blockRoot)
+    if bootstrap.isSome:
+      await response.send(bootstrap.get)
+    else:
+      raise newException(ResourceUnavailableError,
+                         "`LightClientBootstrap` unavailable")
+
+    peer.updateRequestQuota(lightClientBootstrapResponseCost)
+
   proc goodbye(peer: Peer,
                reason: uint64)
     {.async, libp2pProtocol("goodbye", 1).} =