beacon_node RLPx protocols

beacon_sync.nim

type
  BeaconSync* = object
template NetworkState*(P1822062: type BeaconSync): type =
  ref[BeaconSyncState:ObjectType]

type
  statusObj* = object
    networkId*: uint64
    latestFinalizedRoot*: Eth2Digest
    latestFinalizedEpoch*: Epoch
    bestRoot*: Eth2Digest
    bestSlot*: Slot

template status*(T1822071: type BeaconSync): type =
  statusObj

template msgId*(T1822073: type statusObj): int =
  0

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

type
  beaconBlockRootsObj* = object
    roots*: seq[(Eth2Digest, Slot)]

template beaconBlockRoots*(T1822081: type BeaconSync): type =
  beaconBlockRootsObj

template msgId*(T1822083: type beaconBlockRootsObj): int =
  1

template msgProtocol*(T1822085: type beaconBlockRootsObj): type =
  BeaconSync

type
  beaconBlockHeadersObj* = object
    blockHeaders*: seq[BeaconBlockHeaderRLP]

template beaconBlockHeaders*(T1822091: type BeaconSync): type =
  beaconBlockHeadersObj

template msgId*(T1822093: type beaconBlockHeadersObj): int =
  3

template msgProtocol*(T1822095: type beaconBlockHeadersObj): type =
  BeaconSync

type
  getBeaconBlockHeadersObj* = object
    blockRoot*: Eth2Digest
    slot*: Slot
    maxHeaders*: int
    skipSlots*: int

template getBeaconBlockHeaders*(T1822108: type BeaconSync): type =
  getBeaconBlockHeadersObj

template msgId*(T1822110: type getBeaconBlockHeadersObj): int =
  2

template msgProtocol*(T1822112: type getBeaconBlockHeadersObj): type =
  BeaconSync

type
  beaconBlockBodiesObj* = object
    blockBodies*: seq[BeaconBlockBody]

template beaconBlockBodies*(T1822118: type BeaconSync): type =
  beaconBlockBodiesObj

template msgId*(T1822120: type beaconBlockBodiesObj): int =
  5

template msgProtocol*(T1822122: type beaconBlockBodiesObj): type =
  BeaconSync

type
  getBeaconBlockBodiesObj* = object
    blockRoots*: seq[Eth2Digest]

template getBeaconBlockBodies*(T1822135: type BeaconSync): type =
  getBeaconBlockBodiesObj

template msgId*(T1822137: type getBeaconBlockBodiesObj): int =
  4

template msgProtocol*(T1822139: type getBeaconBlockBodiesObj): type =
  BeaconSync

var p1822141 = initProtocol("bcs", 1, nil,
                         createNetworkState[ref[BeaconSyncState:ObjectType]])
var BeaconSyncProtocol = addr p1822141
template protocolInfo*(P1822143: type BeaconSync): ProtocolInfo =
  BeaconSyncProtocol

proc status*(sendTo: Peer; networkId: uint64; latestFinalizedRoot: Eth2Digest;
            latestFinalizedEpoch: Epoch; bestRoot: Eth2Digest; bestSlot: Slot): Future[
    void] {.libp2pProtocol("hello", "1.0.0"), gcsafe.} =
  let msgRecipient = getPeer(sendTo)
  var writer = initRlpWriter()
  const
    perProtocolMsgId = 0
  let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, BeaconSyncProtocol, 0)
  append(writer, perPeerMsgId)
  startList(writer, 5)
  append(writer, networkId)
  append(writer, latestFinalizedRoot)
  append(writer, latestFinalizedEpoch)
  append(writer, bestRoot)
  append(writer, bestSlot)
  let msgBytes = finish(writer)
  return sendMsg(msgRecipient, msgBytes)

proc beaconBlockRoots*(sendTo: Peer; roots: openarray[(Eth2Digest, Slot)]): Future[
    void] {.libp2pProtocol("rpc/beacon_block_roots", "1.0.0"), gcsafe.} =
  let msgRecipient = getPeer(sendTo)
  var writer = initRlpWriter()
  const
    perProtocolMsgId = 1
  let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, BeaconSyncProtocol, 1)
  append(writer, perPeerMsgId)
  append(writer, roots)
  let msgBytes = finish(writer)
  return sendMsg(msgRecipient, msgBytes)

proc beaconBlockHeaders*(sendTo: ResponseWithId[beaconBlockHeadersObj];
                        blockHeaders: openarray[BeaconBlockHeaderRLP]): Future[
    void] {.gcsafe.} =
  let msgRecipient = getPeer(sendTo)
  var writer = initRlpWriter()
  const
    perProtocolMsgId = 3
  let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, BeaconSyncProtocol, 3)
  append(writer, perPeerMsgId)
  startList(writer, 2)
  append(writer, sendTo.id)
  append(writer, blockHeaders)
  let msgBytes = finish(writer)
  return sendMsg(msgRecipient, msgBytes)

template send*(r1822097: ResponseWithId[beaconBlockHeadersObj]; args1822099: varargs[
    untyped]): auto =
  beaconBlockHeaders(r1822097, args1822099)

proc getBeaconBlockHeaders*(sendTo: Peer; blockRoot: Eth2Digest; slot: Slot;
                           maxHeaders: int; skipSlots: int; timeout: Duration = milliseconds(
    10000'i64)): Future[Option[beaconBlockHeadersObj]] {.
    libp2pProtocol("rpc/beacon_block_headers", "1.0.0"), gcsafe.} =
  let msgRecipient = getPeer(sendTo)
  var writer = initRlpWriter()
  const
    perProtocolMsgId = 2
  let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, BeaconSyncProtocol, 2)
  append(writer, perPeerMsgId)
  startList(writer, 5)
  newFuture result
  let reqId = registerRequest(msgRecipient, timeout, result, perPeerMsgId +
      1)
  append(writer, reqId)
  append(writer, blockRoot)
  append(writer, slot)
  append(writer, maxHeaders)
  append(writer, skipSlots)
  let msgBytes = finish(writer)
  linkSendFailureToReqFuture(sendMsg(msgRecipient, msgBytes), result)

proc beaconBlockBodies*(sendTo: ResponseWithId[beaconBlockBodiesObj];
                       blockBodies: openarray[BeaconBlockBody]): Future[void] {.
    gcsafe.} =
  let msgRecipient = getPeer(sendTo)
  var writer = initRlpWriter()
  const
    perProtocolMsgId = 5
  let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, BeaconSyncProtocol, 5)
  append(writer, perPeerMsgId)
  startList(writer, 2)
  append(writer, sendTo.id)
  append(writer, blockBodies)
  let msgBytes = finish(writer)
  return sendMsg(msgRecipient, msgBytes)

template send*(r1822124: ResponseWithId[beaconBlockBodiesObj]; args1822126: varargs[
    untyped]): auto =
  beaconBlockBodies(r1822124, args1822126)

proc getBeaconBlockBodies*(sendTo: Peer; blockRoots: openarray[Eth2Digest]; timeout: Duration = milliseconds(
    10000'i64)): Future[Option[beaconBlockBodiesObj]] {.
    libp2pProtocol("rpc/beacon_block_bodies", "1.0.0"), gcsafe.} =
  let msgRecipient = getPeer(sendTo)
  var writer = initRlpWriter()
  const
    perProtocolMsgId = 4
  let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, BeaconSyncProtocol, 4)
  append(writer, perPeerMsgId)
  startList(writer, 2)
  newFuture result
  let reqId = registerRequest(msgRecipient, timeout, result, perPeerMsgId +
      1)
  append(writer, reqId)
  append(writer, blockRoots)
  let msgBytes = finish(writer)
  linkSendFailureToReqFuture(sendMsg(msgRecipient, msgBytes), result)

proc BeaconSyncHandshake1822063(peer: Peer) {.gcsafe, async.} =
  type
    CurrentProtocol = BeaconSync
  template networkState(p1822065: Peer): ref[BeaconSyncState:ObjectType] =
    cast[ref[BeaconSyncState:ObjectType]](getNetworkState(p1822065.network,
        BeaconSyncProtocol))

  let
    protocolVersion = 1
    node = peer.networkState.node
    networkId = peer.networkState.networkId
  var
    latestFinalizedRoot: Eth2Digest
    latestFinalizedEpoch = node.state.data.finalized_epoch
    bestRoot: Eth2Digest
    bestSlot = node.state.data.slot
  let m = await handshake(peer, timeout = 10.seconds, status(networkId,
      latestFinalizedRoot, latestFinalizedEpoch, bestRoot, bestSlot))
  if m.networkId != networkId:
    await peer.disconnect(UselessPeer)
    return
  try:
    let bestDiff = cmp((latestFinalizedEpoch, bestSlot),
                    (m.latestFinalizedEpoch, m.bestSlot))
    if bestDiff == 0:
      trace "Nothing to sync", peer = peer.remote
    else:
      let blockPool = peer.networkState.node.blockPool
      if bestDiff > 0:
        type
          Root = (Eth2Digest, Slot)
        var roots = newSeqOfCap[Root](128)
        for i in int(m.bestSlot) .. int(bestSlot):
          for r in blockPool.blockRootsForSlot(i.Slot):
            roots.add((r, i.Slot))
        await peer.beaconBlockRoots(roots)
      else:
        let roots = await peer.nextMsg(BeaconSync.beaconBlockRoots)
        let headers = await peer.getBeaconBlockHeaders(bestRoot, bestSlot,
            roots.roots.len, 0)
        var bodiesRequest = newSeqOfCap[Eth2Digest](roots.roots.len)
        for r in roots.roots:
          bodiesRequest.add(r[0])
        let bodies = await peer.getBeaconBlockBodies(bodiesRequest)
        node.importBlocks(roots.roots, headers.get.blockHeaders,
                          bodies.get.blockBodies)
  except CatchableError:
    warn "Failed to sync with peer", peer, err = getCurrentExceptionMsg()

proc status_thunk(msgSender: Peer; _1822067: int; data1822069: Rlp) {.gcsafe,
    libp2pProtocol("hello", "1.0.0"), async.} =
  var rlp = data1822069
  var msg {.noinit.}: statusObj
  enterList(rlp)
  msg.networkId = checkedRlpRead(msgSender, rlp, uint64)
  msg.latestFinalizedRoot = checkedRlpRead(msgSender, rlp, Eth2Digest)
  msg.latestFinalizedEpoch = checkedRlpRead(msgSender, rlp, Epoch)
  msg.bestRoot = checkedRlpRead(msgSender, rlp, Eth2Digest)
  msg.bestSlot = checkedRlpRead(msgSender, rlp, Slot)
  
proc beaconBlockRoots_thunk(msgSender: Peer; _1822077: int; data1822079: Rlp) {.gcsafe,
    libp2pProtocol("rpc/beacon_block_roots", "1.0.0"), async.} =
  var rlp = data1822079
  var msg {.noinit.}: beaconBlockRootsObj
  msg.roots = checkedRlpRead(msgSender, rlp, openarray[(Eth2Digest, Slot)])
  
proc beaconBlockHeaders_thunk(msgSender: Peer; _1822087: int; data1822089: Rlp) {.
    gcsafe, async.} =
  var rlp = data1822089
  var msg {.noinit.}: beaconBlockHeadersObj
  enterList(rlp)
  let reqId = read(rlp, int)
  msg.blockHeaders = checkedRlpRead(msgSender, rlp, openarray[BeaconBlockHeaderRLP])
  resolveResponseFuture(msgSender,
                        perPeerMsgId(msgSender, beaconBlockHeadersObj), addr(msg),
                        reqId)

proc getBeaconBlockHeaders1822100(peer: Peer; reqId: int; blockRoot: Eth2Digest;
                                 slot: Slot; maxHeaders: int; skipSlots: int) {.
    libp2pProtocol("rpc/beacon_block_headers", "1.0.0"), gcsafe, async.} =
  type
    CurrentProtocol = BeaconSync
  let response = ResponseWithId[beaconBlockHeadersObj](peer: peer, id: reqId)
  const
    perProtocolMsgId = 2
  template networkState(p1822102: Peer): ref[BeaconSyncState:ObjectType] =
    cast[ref[BeaconSyncState:ObjectType]](getNetworkState(p1822102.network,
        BeaconSyncProtocol))

  var s = slot.int
  var headers = newSeqOfCap[BeaconBlockHeaderRLP](maxHeaders)
  let db = peer.networkState.db
  let blockPool = peer.networkState.node.blockPool
  while headers.len < maxHeaders:
    for r in blockPool.blockRootsForSlot(s.Slot):
      headers.add(db.getBlock(r).get().toHeader)
      if headers.len == maxHeaders:
        break
    inc s
  await response.send(headers)

proc getBeaconBlockHeaders_thunk(msgSender: Peer; _1822104: int; data1822106: Rlp) {.
    gcsafe, libp2pProtocol("rpc/beacon_block_headers", "1.0.0"), async.} =
  var rlp = data1822106
  var msg {.noinit.}: getBeaconBlockHeadersObj
  enterList(rlp)
  let reqId = read(rlp, int)
  msg.blockRoot = checkedRlpRead(msgSender, rlp, Eth2Digest)
  msg.slot = checkedRlpRead(msgSender, rlp, Slot)
  msg.maxHeaders = checkedRlpRead(msgSender, rlp, int)
  msg.skipSlots = checkedRlpRead(msgSender, rlp, int)
  await(getBeaconBlockHeaders1822100(msgSender, reqId, msg.blockRoot, msg.slot,
                                     msg.maxHeaders, msg.skipSlots))
  
proc beaconBlockBodies_thunk(msgSender: Peer; _1822114: int; data1822116: Rlp) {.
    gcsafe, async.} =
  var rlp = data1822116
  var msg {.noinit.}: beaconBlockBodiesObj
  enterList(rlp)
  let reqId = read(rlp, int)
  msg.blockBodies = checkedRlpRead(msgSender, rlp, openarray[BeaconBlockBody])
  resolveResponseFuture(msgSender, perPeerMsgId(msgSender, beaconBlockBodiesObj),
                        addr(msg), reqId)

proc getBeaconBlockBodies1822127(peer: Peer; reqId: int; blockRoots: seq[Eth2Digest]) {.
    libp2pProtocol("rpc/beacon_block_bodies", "1.0.0"), gcsafe, async.} =
  type
    CurrentProtocol = BeaconSync
  let response = ResponseWithId[beaconBlockBodiesObj](peer: peer, id: reqId)
  const
    perProtocolMsgId = 4
  template networkState(p1822129: Peer): ref[BeaconSyncState:ObjectType] =
    cast[ref[BeaconSyncState:ObjectType]](getNetworkState(p1822129.network,
        BeaconSyncProtocol))

  var bodies = newSeqOfCap[BeaconBlockBody](blockRoots.len)
  let db = peer.networkState.db
  for r in blockRoots:
    if (
      let blk = db.getBlock(r)
      blk.isSome):
      bodies.add(blk.get().body)
  await response.send(bodies)

proc getBeaconBlockBodies_thunk(msgSender: Peer; _1822131: int; data1822133: Rlp) {.
    gcsafe, libp2pProtocol("rpc/beacon_block_bodies", "1.0.0"), async.} =
  var rlp = data1822133
  var msg {.noinit.}: getBeaconBlockBodiesObj
  enterList(rlp)
  let reqId = read(rlp, int)
  msg.blockRoots = checkedRlpRead(msgSender, rlp, openarray[Eth2Digest])
  await(getBeaconBlockBodies1822127(msgSender, reqId, msg.blockRoots))
  
registerMsg(BeaconSyncProtocol, 0, "status", status_thunk,
            messagePrinter[statusObj], requestResolver[statusObj],
            nextMsgResolver[statusObj])
registerMsg(BeaconSyncProtocol, 1, "beaconBlockRoots", beaconBlockRoots_thunk,
            messagePrinter[beaconBlockRootsObj],
            requestResolver[beaconBlockRootsObj],
            nextMsgResolver[beaconBlockRootsObj])
registerMsg(BeaconSyncProtocol, 3, "beaconBlockHeaders", beaconBlockHeaders_thunk,
            messagePrinter[beaconBlockHeadersObj],
            requestResolver[beaconBlockHeadersObj],
            nextMsgResolver[beaconBlockHeadersObj])
registerMsg(BeaconSyncProtocol, 2, "getBeaconBlockHeaders",
            getBeaconBlockHeaders_thunk,
            messagePrinter[getBeaconBlockHeadersObj],
            requestResolver[getBeaconBlockHeadersObj],
            nextMsgResolver[getBeaconBlockHeadersObj])
registerMsg(BeaconSyncProtocol, 5, "beaconBlockBodies", beaconBlockBodies_thunk,
            messagePrinter[beaconBlockBodiesObj],
            requestResolver[beaconBlockBodiesObj],
            nextMsgResolver[beaconBlockBodiesObj])
registerMsg(BeaconSyncProtocol, 4, "getBeaconBlockBodies",
            getBeaconBlockBodies_thunk, messagePrinter[getBeaconBlockBodiesObj],
            requestResolver[getBeaconBlockBodiesObj],
            nextMsgResolver[getBeaconBlockBodiesObj])
setEventHandlers(BeaconSyncProtocol, BeaconSyncHandshake1822063, nil)
registerProtocol(BeaconSyncProtocol)

devp2p.nim

type
  devp2p* = object
type
  helloObj* = object
    version*: uint
    clientId*: string
    capabilities*: seq[Capability]
    listenPort*: uint
    nodeId*: array[RawPublicKeySize, byte]

template hello*(T1499567: type devp2p): type =
  helloObj

template msgId*(T1499569: type helloObj): int =
  0

template msgProtocol*(T1499571: type helloObj): type =
  devp2p

type
  sendDisconnectMsgObj* = object
    reason*: DisconnectionReason

template sendDisconnectMsg*(T1499577: type devp2p): type =
  sendDisconnectMsgObj

template msgId*(T1499579: type sendDisconnectMsgObj): int =
  1

template msgProtocol*(T1499581: type sendDisconnectMsgObj): type =
  devp2p

type
  pingObj* = object
  
template ping*(T1499588: type devp2p): type =
  pingObj

template msgId*(T1499590: type pingObj): int =
  2

template msgProtocol*(T1499592: type pingObj): type =
  devp2p

type
  pongObj* = object
  
template pong*(T1499599: type devp2p): type =
  pongObj

template msgId*(T1499601: type pongObj): int =
  3

template msgProtocol*(T1499603: type pongObj): type =
  devp2p

var p1499605 = initProtocol("p2p", 0, nil, nil)
var devp2pProtocol = addr p1499605
template protocolInfo*(P1499607: type devp2p): ProtocolInfo =
  devp2pProtocol

proc hello*(sendTo: Peer; version: uint; clientId: string;
           capabilities: seq[Capability]; listenPort: uint;
           nodeId: array[RawPublicKeySize, byte]): Future[void] {.gcsafe.} =
  let msgRecipient = getPeer(sendTo)
  var writer = initRlpWriter()
  const
    perProtocolMsgId = 0
  let perPeerMsgId = 0
  append(writer, perPeerMsgId)
  startList(writer, 5)
  append(writer, version)
  append(writer, clientId)
  append(writer, capabilities)
  append(writer, listenPort)
  append(writer, nodeId)
  let msgBytes = finish(writer)
  return sendMsg(msgRecipient, msgBytes)

proc sendDisconnectMsg*(sendTo: Peer; reason: DisconnectionReason): Future[void] {.
    gcsafe.} =
  let msgRecipient = getPeer(sendTo)
  var writer = initRlpWriter()
  const
    perProtocolMsgId = 1
  let perPeerMsgId = 1
  append(writer, perPeerMsgId)
  append(writer, reason)
  let msgBytes = finish(writer)
  return sendMsg(msgRecipient, msgBytes)

proc ping*(sendTo: Peer): Future[void] {.gcsafe.} =
  let msgRecipient = getPeer(sendTo)
  var writer = initRlpWriter()
  const
    perProtocolMsgId = 2
  let perPeerMsgId = 2
  append(writer, perPeerMsgId)
  let msgBytes = finish(writer)
  return sendMsg(msgRecipient, msgBytes)

proc pong*(sendTo: Peer): Future[void] {.gcsafe.} =
  let msgRecipient = getPeer(sendTo)
  var writer = initRlpWriter()
  const
    perProtocolMsgId = 3
  let perPeerMsgId = 3
  append(writer, perPeerMsgId)
  let msgBytes = finish(writer)
  return sendMsg(msgRecipient, msgBytes)

proc hello_thunk(msgSender: Peer; _1499563: int; data1499565: Rlp) {.gcsafe, async.} =
  var rlp = data1499565
  var msg {.noinit.}: helloObj
  enterList(rlp)
  msg.version = checkedRlpRead(msgSender, rlp, uint)
  msg.clientId = checkedRlpRead(msgSender, rlp, string)
  msg.capabilities = checkedRlpRead(msgSender, rlp, seq[Capability])
  msg.listenPort = checkedRlpRead(msgSender, rlp, uint)
  msg.nodeId = checkedRlpRead(msgSender, rlp, array[RawPublicKeySize, byte])
  
proc sendDisconnectMsg_thunk(msgSender: Peer; _1499573: int; data1499575: Rlp) {.
    gcsafe, async.} =
  var rlp = data1499575
  var msg {.noinit.}: sendDisconnectMsgObj
  msg.reason = checkedRlpRead(msgSender, rlp, DisconnectionReason)
  
proc ping1499582(peer: Peer) {.gcsafe, async.} =
  type
    CurrentProtocol = devp2p
  const
    perProtocolMsgId = 2
  discard peer.pong()

proc ping_thunk(msgSender: Peer; _1499584: int; data1499586: Rlp) {.gcsafe, async.} =
  var rlp = data1499586
  var msg {.noinit.}: pingObj
  await(ping1499582(msgSender))
  
proc pong1499593(peer: Peer) {.gcsafe, async.} =
  type
    CurrentProtocol = devp2p
  const
    perProtocolMsgId = 3
  discard

proc pong_thunk(msgSender: Peer; _1499595: int; data1499597: Rlp) {.gcsafe, async.} =
  var rlp = data1499597
  var msg {.noinit.}: pongObj
  await(pong1499593(msgSender))
  
registerMsg(devp2pProtocol, 0, "hello", hello_thunk, messagePrinter[helloObj],
            requestResolver[helloObj], nextMsgResolver[helloObj])
registerMsg(devp2pProtocol, 1, "sendDisconnectMsg", sendDisconnectMsg_thunk,
            messagePrinter[sendDisconnectMsgObj],
            requestResolver[sendDisconnectMsgObj],
            nextMsgResolver[sendDisconnectMsgObj])
registerMsg(devp2pProtocol, 2, "ping", ping_thunk, messagePrinter[pingObj],
            requestResolver[pingObj], nextMsgResolver[pingObj])
registerMsg(devp2pProtocol, 3, "pong", pong_thunk, messagePrinter[pongObj],
            requestResolver[pongObj], nextMsgResolver[pongObj])
setEventHandlers(devp2pProtocol, nil, nil)
registerProtocol(devp2pProtocol)

gossip_sub.nim

type
  GossipSub* = object
template State*(P1660534: type GossipSub): type =
  ref[GossipSubPeer:ObjectType]

template NetworkState*(P1660536: type GossipSub): type =
  ref[GossipSubNetwork:ObjectType]

type
  subscribeForObj* = object
    topic*: string

template subscribeFor*(T1660557: type GossipSub): type =
  subscribeForObj

template msgId*(T1660559: type subscribeForObj): int =
  0

template msgProtocol*(T1660561: type subscribeForObj): type =
  GossipSub

type
  emitObj* = object
    topic*: string
    msgId*: string
    msg*: string

template emit*(T1660572: type GossipSub): type =
  emitObj

template msgId*(T1660574: type emitObj): int =
  1

template msgProtocol*(T1660576: type emitObj): type =
  GossipSub

var p1660578 = initProtocol("gss", 1, createPeerState[ref[GossipSubPeer:ObjectType]],
                         createNetworkState[ref[GossipSubNetwork:ObjectType]])
var GossipSubProtocol = addr p1660578
template protocolInfo*(P1660580: type GossipSub): ProtocolInfo =
  GossipSubProtocol

proc subscribeFor*(sendTo: Peer; topic: string): Future[void] {.gcsafe.} =
  let msgRecipient = getPeer(sendTo)
  var writer = initRlpWriter()
  const
    perProtocolMsgId = 0
  let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, GossipSubProtocol, 0)
  append(writer, perPeerMsgId)
  append(writer, topic)
  let msgBytes = finish(writer)
  return sendMsg(msgRecipient, msgBytes)

proc emit*(sendTo: Peer; topic: string; msgId: string; msg: string): Future[void] {.gcsafe.} =
  let msgRecipient = getPeer(sendTo)
  var writer = initRlpWriter()
  const
    perProtocolMsgId = 1
  let perPeerMsgId = perPeerMsgIdImpl(msgRecipient, GossipSubProtocol, 1)
  append(writer, perPeerMsgId)
  startList(writer, 3)
  append(writer, topic)
  append(writer, msgId)
  append(writer, msg)
  let msgBytes = finish(writer)
  return sendMsg(msgRecipient, msgBytes)

proc GossipSubHandshake1660537(peer: Peer) {.gcsafe, async.} =
  type
    CurrentProtocol = GossipSub
  template state(p1660539: Peer): ref[GossipSubPeer:ObjectType] =
    cast[ref[GossipSubPeer:ObjectType]](getState(p1660539, GossipSubProtocol))

  template networkState(p1660541: Peer): ref[GossipSubNetwork:ObjectType] =
    cast[ref[GossipSubNetwork:ObjectType]](getNetworkState(p1660541.network,
        GossipSubProtocol))

  info "GossipSub Peer connected", peer
  let gossipNet = peer.networkState
  for topic, _ in gossipNet.topicSubscribers:
    peer.trySubscribing(topic)

proc GossipSubPeerDisconnect1660542(peer: Peer; reason: DisconnectionReason) {.
    gcsafe, async.} =
  type
    CurrentProtocol = GossipSub
  template state(p1660544: Peer): ref[GossipSubPeer:ObjectType] =
    cast[ref[GossipSubPeer:ObjectType]](getState(p1660544, GossipSubProtocol))

  template networkState(p1660546: Peer): ref[GossipSubNetwork:ObjectType] =
    cast[ref[GossipSubNetwork:ObjectType]](getNetworkState(p1660546.network,
        GossipSubProtocol))

  info "GossipSub Peer disconnected", peer, reason

proc subscribeFor1660547(peer: Peer; topic: string) {.gcsafe, async.} =
  type
    CurrentProtocol = GossipSub
  const
    perProtocolMsgId = 0
  template state(p1660549: Peer): ref[GossipSubPeer:ObjectType] =
    cast[ref[GossipSubPeer:ObjectType]](getState(p1660549, GossipSubProtocol))

  template networkState(p1660551: Peer): ref[GossipSubNetwork:ObjectType] =
    cast[ref[GossipSubNetwork:ObjectType]](getNetworkState(p1660551.network,
        GossipSubProtocol))

  peer.state.subscribedFor.incl topic

proc subscribeFor_thunk(msgSender: Peer; _1660553: int; data1660555: Rlp) {.gcsafe,
    async.} =
  var rlp = data1660555
  var msg {.noinit.}: subscribeForObj
  msg.topic = checkedRlpRead(msgSender, rlp, string)
  await(subscribeFor1660547(msgSender, msg.topic))
  
proc emit1660562(peer: Peer; topic: string; msgId: string; msg: string) {.gcsafe, async.} =
  type
    CurrentProtocol = GossipSub
  const
    perProtocolMsgId = 1
  template state(p1660564: Peer): ref[GossipSubPeer:ObjectType] =
    cast[ref[GossipSubPeer:ObjectType]](getState(p1660564, GossipSubProtocol))

  template networkState(p1660566: Peer): ref[GossipSubNetwork:ObjectType] =
    cast[ref[GossipSubNetwork:ObjectType]](getNetworkState(p1660566.network,
        GossipSubProtocol))

  if msgId in peer.networkState.handledMessages:
    trace "Ignored previously handled message", msgId
    return
  peer.networkState.handledMessages.incl msgId
  for p in peer.network.peers(GossipSub):
    if msgId notin p.state.sentMessages and topic in p.state.subscribedFor:
      p.state.sentMessages.incl msgId
      asyncDiscard p.tryEmitting(topic, msgId, msg)
  {.gcsafe.}:
    let handler = peer.networkState.topicSubscribers.getOrDefault(topic)
    if handler != nil:
      handler(msg)

proc emit_thunk(msgSender: Peer; _1660568: int; data1660570: Rlp) {.gcsafe, async.} =
  var rlp = data1660570
  var msg {.noinit.}: emitObj
  enterList(rlp)
  msg.topic = checkedRlpRead(msgSender, rlp, string)
  msg.msgId = checkedRlpRead(msgSender, rlp, string)
  msg.msg = checkedRlpRead(msgSender, rlp, string)
  await(emit1660562(msgSender, msg.topic, msg.msgId, msg.msg))
  
registerMsg(GossipSubProtocol, 0, "subscribeFor", subscribeFor_thunk,
            messagePrinter[subscribeForObj], requestResolver[subscribeForObj],
            nextMsgResolver[subscribeForObj])
registerMsg(GossipSubProtocol, 1, "emit", emit_thunk, messagePrinter[emitObj],
            requestResolver[emitObj], nextMsgResolver[emitObj])
setEventHandlers(GossipSubProtocol, GossipSubHandshake1660537,
                 GossipSubPeerDisconnect1660542)
registerProtocol(GossipSubProtocol)