type NodeInfoType = {
  /** Enode URL of the node */
  readonly enode: PeerIdType
  /** Node ID (hex-encoded public key) */
  readonly id: string
  /** External IP address */
  readonly ip: string
  /** Listen address (IP:PORT) */
  readonly listenAddr: string
  /** Client identifier */
  readonly name: string
  /** Network ports */
  readonly ports: {
    /** UDP discovery port */
    readonly discovery: number
    /** TCP listener port */
    readonly listener: number
  }
  /** Protocol-specific information */
  readonly protocols: {
    /** Ethereum protocol info */
    readonly eth?: {
      readonly network: NetworkIdType
      readonly difficulty: BrandedUint
      readonly genesis: BlockHashType
      readonly head: BlockHashType
      readonly config: Record<string, unknown>
    }
    readonly [protocol: string]: unknown
  }
}

import * as NodeInfo from '@tevm/voltaire/NodeInfo'

// From RPC response object
const nodeInfo = NodeInfo.from(rpcResponse)

import * as NodeInfo from '@tevm/voltaire/NodeInfo'

const nodeInfo = NodeInfo.from(data)

// Get protocol-specific information
const ethInfo = NodeInfo.getProtocol(nodeInfo, "eth")
const snapInfo = NodeInfo.getProtocol(nodeInfo, "snap")

nodeInfo.enode
// "enode://abc123...@192.168.1.1:30303?discport=30301"

nodeInfo.name
// "Geth/v1.13.0-stable/linux-amd64/go1.21.0"
// "Nethermind/v1.21.0/linux-x64/dotnet7.0.11"
// "Erigon/v2.55.0/linux-amd64/go1.21.0"

nodeInfo.ports.discovery  // UDP port for peer discovery (default: 30303)
nodeInfo.ports.listener   // TCP port for RLPx connections (default: 30303)

const eth = nodeInfo.protocols.eth

eth?.network     // Network ID (1 for mainnet)
eth?.difficulty  // Total chain difficulty
eth?.genesis     // Genesis block hash
eth?.head        // Current head block hash
eth?.config      // Chain configuration

import * as NodeInfo from '@tevm/voltaire/NodeInfo'

async function monitorNode(rpcUrl: string) {
  const response = await fetch(rpcUrl, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      method: 'admin_nodeInfo',
      params: [],
      id: 1
    })
  })
  const { result } = await response.json()
  const nodeInfo = NodeInfo.from(result)

  return {
    client: nodeInfo.name,
    ip: nodeInfo.ip,
    enode: nodeInfo.enode,
    network: nodeInfo.protocols.eth?.network,
    headBlock: nodeInfo.protocols.eth?.head
  }
}

import * as NodeInfo from '@tevm/voltaire/NodeInfo'

function parseClientVersion(nodeInfo: NodeInfoType) {
  const name = nodeInfo.name
  const parts = name.split('/')

  return {
    client: parts[0],           // "Geth", "Nethermind", etc.
    version: parts[1],          // "v1.13.0-stable"
    platform: parts[2],         // "linux-amd64"
    runtime: parts[3]           // "go1.21.0"
  }
}

function isGeth(nodeInfo: NodeInfoType): boolean {
  return nodeInfo.name.startsWith('Geth/')
}

function meetsMinVersion(nodeInfo: NodeInfoType, minVersion: string): boolean {
  const version = parseClientVersion(nodeInfo).version
  // Version comparison logic
  return version >= minVersion
}

import * as NodeInfo from '@tevm/voltaire/NodeInfo'

function getSupportedProtocols(nodeInfo: NodeInfoType): string[] {
  return Object.keys(nodeInfo.protocols)
}

function supportsSnap(nodeInfo: NodeInfoType): boolean {
  return 'snap' in nodeInfo.protocols
}

function supportsLes(nodeInfo: NodeInfoType): boolean {
  return 'les' in nodeInfo.protocols
}