devp2p_probe.nim

# Copyright (c) 2020-2026 dcrawl contributors
# Licensed under either of
#  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE))
#  * MIT license ([LICENSE-MIT](LICENSE-MIT))
# at your option.
# This file may not be copied, modified, or distributed except according to
# those terms.

## Minimal devp2p (RLPx) probe used to capture a remote peer's
## `clientId` from its Hello message, for EL client identification.
##
## Wraps `rlpxConnect(helloOnly = true)` with a singleton EthereumNode
## so the caller can reuse it across thousands of probes.

{.push raises: [].}

import
  std/[options, net],
  chronos, chronicles,
  eth/keys,
  eth/p2p,
  eth/p2p/[enode, kademlia],
  eth/p2p/discoveryv5/[node as v5node, enr]

logScope:
  topics = "devp2p"

type
  DevP2pProbe* = ref object
    ethNode: EthereumNode

proc createDevP2pProbe*(
    ourKeys: KeyPair, ourClientId: string,
    rng: ref HmacDrbgContext): DevP2pProbe {.raises: [CatchableError].} =
  ## Build a singleton EthereumNode for use as the dialer in all
  ## subsequent `tryDevp2pHello` calls. Discovery v4 / peer pool /
  ## capability protocols are created but never started — we only use
  ## `rlpxConnect`.
  let ethNode = newEthereumNode(
    keys = ourKeys,
    address = enode.Address(
      ip: parseIpAddress("0.0.0.0"),
      udpPort: Port(0),
      tcpPort: Port(0)),
    networkId = 1.NetworkId,
    clientId = ourClientId,
    addAllCapabilities = false,
    bindUdpPort = Port(0),
    bindTcpPort = Port(0),
    rng = rng)
  DevP2pProbe(ethNode: ethNode)

type
  DevP2pHelloResult* = object
    clientId*: string
    disconnectReason*: Option[uint8]

proc tryDevp2pHello*(
    probe: DevP2pProbe, n: v5node.Node, timeoutS: int):
    Future[Option[DevP2pHelloResult]] {.async: (raises: [CancelledError]).} =
  ## Returns Some(result) if the remote peer completes the RLPx
  ## handshake and sends a Hello, None otherwise. The Hello-only path
  ## also waits briefly for an incoming devp2p Disconnect to capture
  ## the reason code (peers usually send one because we declare no
  ## shared subprotocols). Closes the TCP connection on the way out.
  let tcpPortOpt = n.record.tryGet("tcp", int)
  if tcpPortOpt.isNone: return none(DevP2pHelloResult)
  if n.address.isNone: return none(DevP2pHelloResult)

  let kAddress = enode.Address(
    ip: n.address.get().ip,
    udpPort: Port(0),
    tcpPort: Port(tcpPortOpt.get()))
  let kEnode = ENode(pubkey: n.pubkey, address: kAddress)
  let kNode = newNode(kEnode)

  var peer: Peer = nil
  try:
    let res = await rlpxConnect(probe.ethNode, kNode, helloOnly = true)
                  .wait(timeoutS.seconds)
    if res.isErr:
      debug "devp2p handshake error",
        id = n.id.toHex, error = res.error
      return none(DevP2pHelloResult)
    peer = res.value
  except CancelledError as e:
    raise e
  except CatchableError as e:
    debug "devp2p connect failed", id = n.id.toHex, error = e.msg
    return none(DevP2pHelloResult)

  let clientId = peer.clientId
  let dr =
    if peer.disconnectReason.isSome: some(peer.disconnectReason.get())
    else: none(uint8)
  try:
    if not peer.transport.isNil and not peer.transport.closed:
      peer.transport.close()
  except CatchableError:
    discard

  return some(DevP2pHelloResult(clientId: clientId, disconnectReason: dr))

{.pop.}