## Generated at line 87
type
  BeaconSync* = object
template State*(PROTO: type BeaconSync): type =
  ref[BeaconSyncPeerState:ObjectType]

template NetworkState*(PROTO: type BeaconSync): type =
  ref[BeaconSyncNetworkState:ObjectType]

type
  statusObj* = distinct StatusMsg
template status*(PROTO: type BeaconSync): type =
  StatusMsg

template msgProtocol*(MSG: type statusObj): type =
  BeaconSync

template RecType*(MSG: type statusObj): untyped =
  StatusMsg

type
  pingObj* = distinct uint64
template ping*(PROTO: type BeaconSync): type =
  uint64

template msgProtocol*(MSG: type pingObj): type =
  BeaconSync

template RecType*(MSG: type pingObj): untyped =
  uint64

type
  getMetadataObj* = object
  
template getMetadata*(PROTO: type BeaconSync): type =
  getMetadataObj

template msgProtocol*(MSG: type getMetadataObj): type =
  BeaconSync

template RecType*(MSG: type getMetadataObj): untyped =
  getMetadataObj

type
  beaconBlocksByRangeObj* = object
    startSlot*: Slot
    count*: uint64
    step*: uint64

template beaconBlocksByRange*(PROTO: type BeaconSync): type =
  beaconBlocksByRangeObj

template msgProtocol*(MSG: type beaconBlocksByRangeObj): type =
  BeaconSync

template RecType*(MSG: type beaconBlocksByRangeObj): untyped =
  beaconBlocksByRangeObj

type
  beaconBlocksByRootObj* = distinct BlockRootsList
template beaconBlocksByRoot*(PROTO: type BeaconSync): type =
  BlockRootsList

template msgProtocol*(MSG: type beaconBlocksByRootObj): type =
  BeaconSync

template RecType*(MSG: type beaconBlocksByRootObj): untyped =
  BlockRootsList

type
  goodbyeObj* = distinct DisconnectionReason
template goodbye*(PROTO: type BeaconSync): type =
  DisconnectionReason

template msgProtocol*(MSG: type goodbyeObj): type =
  BeaconSync

template RecType*(MSG: type goodbyeObj): untyped =
  DisconnectionReason

var BeaconSyncProtocolObj = initProtocol("BeaconSync", createPeerState[Peer,
    ref[BeaconSyncPeerState:ObjectType]], createNetworkState[Eth2Node,
    ref[BeaconSyncNetworkState:ObjectType]])
var BeaconSyncProtocol = addr BeaconSyncProtocolObj
template protocolInfo*(P`gensym187610300: type BeaconSync): auto =
  BeaconSyncProtocol

proc status*(peer: Peer; theirStatus: StatusMsg;
            timeout: Duration = milliseconds(10000'i64)): Future[NetRes[StatusMsg]] {.
    gcsafe, libp2pProtocol("status", 1).} =
  var outputStream = memoryOutput()
  var writer = init(WriterType(SSZ), outputStream)
  writeValue(writer, theirStatus)
  let msgBytes = getOutput(outputStream)
  makeEth2Request(peer, "/eth2/beacon_chain/req/status/1/", msgBytes, StatusMsg,
                  timeout)

proc ping*(peer: Peer; value: uint64; timeout: Duration = milliseconds(10000'i64)): Future[
    NetRes[uint64]] {.gcsafe, libp2pProtocol("ping", 1).} =
  var outputStream = memoryOutput()
  var writer = init(WriterType(SSZ), outputStream)
  writeValue(writer, value)
  let msgBytes = getOutput(outputStream)
  makeEth2Request(peer, "/eth2/beacon_chain/req/ping/1/", msgBytes, uint64, timeout)

proc getMetadata*(peer: Peer; timeout: Duration = milliseconds(10000'i64)): Future[
    NetRes[Eth2Metadata]] {.gcsafe, libp2pProtocol("metadata", 1).} =
  var msgBytes: seq[byte]
  makeEth2Request(peer, "/eth2/beacon_chain/req/metadata/1/", msgBytes,
                  Eth2Metadata, timeout)

proc beaconBlocksByRange*(peer: Peer; startSlot: Slot; count: uint64; step: uint64;
                         timeout: Duration = milliseconds(10000'i64)): Future[
    NetRes[seq[SignedBeaconBlock]]] {.gcsafe, libp2pProtocol(
    "beacon_blocks_by_range", 1).} =
  var outputStream = memoryOutput()
  var writer = init(WriterType(SSZ), outputStream)
  var recordWriterCtx = beginRecord(writer, beaconBlocksByRangeObj)
  writeField(writer, recordWriterCtx, "startSlot", startSlot)
  writeField(writer, recordWriterCtx, "count", count)
  writeField(writer, recordWriterCtx, "step", step)
  endRecord(writer, recordWriterCtx)
  let msgBytes = getOutput(outputStream)
  makeEth2Request(peer, "/eth2/beacon_chain/req/beacon_blocks_by_range/1/",
                  msgBytes, seq[SignedBeaconBlock], timeout)

proc beaconBlocksByRoot*(peer: Peer; blockRoots: BlockRootsList;
                        timeout: Duration = milliseconds(10000'i64)): Future[
    NetRes[seq[SignedBeaconBlock]]] {.gcsafe,
                                     libp2pProtocol("beacon_blocks_by_root", 1).} =
  var outputStream = memoryOutput()
  var writer = init(WriterType(SSZ), outputStream)
  writeValue(writer, blockRoots)
  let msgBytes = getOutput(outputStream)
  makeEth2Request(peer, "/eth2/beacon_chain/req/beacon_blocks_by_root/1/",
                  msgBytes, seq[SignedBeaconBlock], timeout)

proc goodbye*(peer: Peer; reason: DisconnectionReason): Future[void] {.gcsafe,
    libp2pProtocol("goodbye", 1).} =
  var outputStream = memoryOutput()
  var writer = init(WriterType(SSZ), outputStream)
  writeValue(writer, reason)
  let msgBytes = getOutput(outputStream)
  sendNotificationMsg(peer, "/eth2/beacon_chain/req/goodbye/1/", msgBytes)

proc statusUserHandler(peer: Peer; theirStatus: StatusMsg;
                      response: SingleChunkResponse[StatusMsg]) {.async,
    libp2pProtocol("status", 1), gcsafe.} =
  type
    CurrentProtocol = BeaconSync
  template state(peer: Peer): ref[BeaconSyncPeerState:ObjectType] =
    cast[ref[BeaconSyncPeerState:ObjectType]](getState(peer, BeaconSyncProtocol))

  template networkState(peer: Peer): ref[BeaconSyncNetworkState:ObjectType] =
    cast[ref[BeaconSyncNetworkState:ObjectType]](getNetworkState(peer.network,
        BeaconSyncProtocol))

  let ourStatus = peer.networkState.getCurrentStatus()
  trace "Sending status message", peer = peer, status = ourStatus
  await response.send(ourStatus)
  await peer.handleStatus(peer.networkState, ourStatus, theirStatus)

proc pingUserHandler(peer: Peer; value: uint64): uint64 {.libp2pProtocol("ping", 1),
    gcsafe.} =
  type
    CurrentProtocol = BeaconSync
  template state(peer: Peer): ref[BeaconSyncPeerState:ObjectType] =
    cast[ref[BeaconSyncPeerState:ObjectType]](getState(peer, BeaconSyncProtocol))

  template networkState(peer: Peer): ref[BeaconSyncNetworkState:ObjectType] =
    cast[ref[BeaconSyncNetworkState:ObjectType]](getNetworkState(peer.network,
        BeaconSyncProtocol))

  return peer.network.metadata.seq_number

proc getMetadataUserHandler(peer: Peer): Eth2Metadata {.
    libp2pProtocol("metadata", 1), gcsafe.} =
  type
    CurrentProtocol = BeaconSync
  template state(peer: Peer): ref[BeaconSyncPeerState:ObjectType] =
    cast[ref[BeaconSyncPeerState:ObjectType]](getState(peer, BeaconSyncProtocol))

  template networkState(peer: Peer): ref[BeaconSyncNetworkState:ObjectType] =
    cast[ref[BeaconSyncNetworkState:ObjectType]](getNetworkState(peer.network,
        BeaconSyncProtocol))

  return peer.network.metadata

proc beaconBlocksByRangeUserHandler(peer: Peer; startSlot: Slot; count: uint64;
                                   step: uint64; response: MultipleChunksResponse[
    SignedBeaconBlock]) {.async, libp2pProtocol("beacon_blocks_by_range", 1), gcsafe.} =
  type
    CurrentProtocol = BeaconSync
  template state(peer: Peer): ref[BeaconSyncPeerState:ObjectType] =
    cast[ref[BeaconSyncPeerState:ObjectType]](getState(peer, BeaconSyncProtocol))

  template networkState(peer: Peer): ref[BeaconSyncNetworkState:ObjectType] =
    cast[ref[BeaconSyncNetworkState:ObjectType]](getNetworkState(peer.network,
        BeaconSyncProtocol))

  trace "got range request", peer, startSlot, count, step
  if count > 0'u64:
    var blocks: array[MAX_REQUESTED_BLOCKS, BlockRef]
    let
      pool = peer.networkState.blockPool
      count = min(count.Natural, blocks.len)
    let
      endIndex = count - 1
      startIndex = pool.getBlockRange(startSlot, step,
                                    blocks.toOpenArray(0, endIndex))
    for b in blocks[startIndex .. endIndex]:
      doAssert not b.isNil, "getBlockRange should return non-nil blocks only"
      trace "wrote response block", slot = b.slot, roor = shortLog(b.root)
      await response.write(pool.get(b).data)
    debug "Block range request done", peer, startSlot, count, step,
         found = count - startIndex

proc beaconBlocksByRootUserHandler(peer: Peer; blockRoots: BlockRootsList; response: MultipleChunksResponse[
    SignedBeaconBlock]) {.async, libp2pProtocol("beacon_blocks_by_root", 1), gcsafe.} =
  type
    CurrentProtocol = BeaconSync
  template state(peer: Peer): ref[BeaconSyncPeerState:ObjectType] =
    cast[ref[BeaconSyncPeerState:ObjectType]](getState(peer, BeaconSyncProtocol))

  template networkState(peer: Peer): ref[BeaconSyncNetworkState:ObjectType] =
    cast[ref[BeaconSyncNetworkState:ObjectType]](getNetworkState(peer.network,
        BeaconSyncProtocol))

  let
    pool = peer.networkState.blockPool
    count = blockRoots.len
  var found = 0
  for root in blockRoots[0 ..< count]:
    let blockRef = pool.getRef(root)
    if not isNil(blockRef):
      await response.write(pool.get(blockRef).data)
      inc found
  debug "Block root request done", peer, roots = blockRoots.len, count, found

template callUserHandler(MSG: type statusObj; peer: Peer; stream: Connection;
                        noSnappy: bool; msg: StatusMsg): untyped =
  var response = init(SingleChunkResponse[StatusMsg], peer, stream, noSnappy)
  statusUserHandler(peer, msg, response)

proc status_mounter(network: Eth2Node) =
  proc sszThunk(stream: Connection; protocol: string): Future[void] {.gcsafe.} =
    return handleIncomingStream(network, stream, true, statusObj)

  mount network.switch, LPProtocol(codec: "/eth2/beacon_chain/req/status/1/" &
      "ssz", handler: sszThunk)
  proc snappyThunk(stream: Connection; protocol: string): Future[void] {.gcsafe.} =
    return handleIncomingStream(network, stream, false, statusObj)

  mount network.switch, LPProtocol(codec: "/eth2/beacon_chain/req/status/1/" &
      "ssz_snappy", handler: snappyThunk)

template callUserHandler(MSG: type pingObj; peer: Peer; stream: Connection;
                        noSnappy: bool; msg: uint64): untyped =
  sendUserHandlerResultAsChunkImpl(stream, noSnappy, pingUserHandler(peer, msg))

proc ping_mounter(network: Eth2Node) =
  proc sszThunk(stream: Connection; protocol: string): Future[void] {.gcsafe.} =
    return handleIncomingStream(network, stream, true, pingObj)

  mount network.switch, LPProtocol(codec: "/eth2/beacon_chain/req/ping/1/" & "ssz",
                                 handler: sszThunk)
  proc snappyThunk(stream: Connection; protocol: string): Future[void] {.gcsafe.} =
    return handleIncomingStream(network, stream, false, pingObj)

  mount network.switch, LPProtocol(codec: "/eth2/beacon_chain/req/ping/1/" &
      "ssz_snappy", handler: snappyThunk)

template callUserHandler(MSG: type getMetadataObj; peer: Peer; stream: Connection;
                        noSnappy: bool; msg: getMetadataObj): untyped =
  sendUserHandlerResultAsChunkImpl(stream, noSnappy, getMetadataUserHandler(peer))

proc getMetadata_mounter(network: Eth2Node) =
  proc sszThunk(stream: Connection; protocol: string): Future[void] {.gcsafe.} =
    return handleIncomingStream(network, stream, true, getMetadataObj)

  mount network.switch, LPProtocol(codec: "/eth2/beacon_chain/req/metadata/1/" &
      "ssz", handler: sszThunk)
  proc snappyThunk(stream: Connection; protocol: string): Future[void] {.gcsafe.} =
    return handleIncomingStream(network, stream, false, getMetadataObj)

  mount network.switch, LPProtocol(codec: "/eth2/beacon_chain/req/metadata/1/" &
      "ssz_snappy", handler: snappyThunk)

template callUserHandler(MSG: type beaconBlocksByRangeObj; peer: Peer;
                        stream: Connection; noSnappy: bool;
                        msg: beaconBlocksByRangeObj): untyped =
  var response = init(MultipleChunksResponse[SignedBeaconBlock], peer, stream,
                   noSnappy)
  beaconBlocksByRangeUserHandler(peer, msg.startSlot, msg.count, msg.step, response)

proc beaconBlocksByRange_mounter(network: Eth2Node) =
  proc sszThunk(stream: Connection; protocol: string): Future[void] {.gcsafe.} =
    return handleIncomingStream(network, stream, true, beaconBlocksByRangeObj)

  mount network.switch, LPProtocol(codec: "/eth2/beacon_chain/req/beacon_blocks_by_range/1/" &
      "ssz", handler: sszThunk)
  proc snappyThunk(stream: Connection; protocol: string): Future[void] {.gcsafe.} =
    return handleIncomingStream(network, stream, false, beaconBlocksByRangeObj)

  mount network.switch, LPProtocol(codec: "/eth2/beacon_chain/req/beacon_blocks_by_range/1/" &
      "ssz_snappy", handler: snappyThunk)

template callUserHandler(MSG: type beaconBlocksByRootObj; peer: Peer;
                        stream: Connection; noSnappy: bool; msg: BlockRootsList): untyped =
  var response = init(MultipleChunksResponse[SignedBeaconBlock], peer, stream,
                   noSnappy)
  beaconBlocksByRootUserHandler(peer, msg, response)

proc beaconBlocksByRoot_mounter(network: Eth2Node) =
  proc sszThunk(stream: Connection; protocol: string): Future[void] {.gcsafe.} =
    return handleIncomingStream(network, stream, true, beaconBlocksByRootObj)

  mount network.switch, LPProtocol(codec: "/eth2/beacon_chain/req/beacon_blocks_by_root/1/" &
      "ssz", handler: sszThunk)
  proc snappyThunk(stream: Connection; protocol: string): Future[void] {.gcsafe.} =
    return handleIncomingStream(network, stream, false, beaconBlocksByRootObj)

  mount network.switch, LPProtocol(codec: "/eth2/beacon_chain/req/beacon_blocks_by_root/1/" &
      "ssz_snappy", handler: snappyThunk)

registerMsg(BeaconSyncProtocol, "status", status_mounter,
            "/eth2/beacon_chain/req/status/1/")
registerMsg(BeaconSyncProtocol, "ping", ping_mounter,
            "/eth2/beacon_chain/req/ping/1/")
registerMsg(BeaconSyncProtocol, "getMetadata", getMetadata_mounter,
            "/eth2/beacon_chain/req/metadata/1/")
registerMsg(BeaconSyncProtocol, "beaconBlocksByRange",
            beaconBlocksByRange_mounter,
            "/eth2/beacon_chain/req/beacon_blocks_by_range/1/")
registerMsg(BeaconSyncProtocol, "beaconBlocksByRoot", beaconBlocksByRoot_mounter,
            "/eth2/beacon_chain/req/beacon_blocks_by_root/1/")
registerMsg(BeaconSyncProtocol, "goodbye", nil, "/eth2/beacon_chain/req/goodbye/1/")
proc BeaconSyncPeerConnected(peer: Peer; stream: Connection) {.async, gcsafe.} =
  type
    CurrentProtocol = BeaconSync
  template state(peer: Peer): ref[BeaconSyncPeerState:ObjectType] =
    cast[ref[BeaconSyncPeerState:ObjectType]](getState(peer, BeaconSyncProtocol))

  template networkState(peer: Peer): ref[BeaconSyncNetworkState:ObjectType] =
    cast[ref[BeaconSyncNetworkState:ObjectType]](getNetworkState(peer.network,
        BeaconSyncProtocol))

  if peer.wasDialed:
    let
      ourStatus = peer.networkState.getCurrentStatus()
      theirStatus = await peer.status(ourStatus, timeout = 60.seconds)
    if theirStatus.isOk:
      await peer.handleStatus(peer.networkState, ourStatus, theirStatus.get())
    else:
      warn "Status response not received in time", peer = peer

setEventHandlers(BeaconSyncProtocol, BeaconSyncPeerConnected, nil)
registerProtocol(BeaconSyncProtocol)