Connectionless Transport

Connectionless protocols send data in self-contained packets called datagrams. Each datagram includes the full destination address and is routed independently, with no guarantee of order or delivery. This contrasts with connection-oriented protocols that use a continuous byte stream.

• Example: The User Datagram Protocol (UDP) is the canonical example, sending discrete messages.
• Key Benefit: Eliminates the overhead of connection setup and teardown phases.

The sender and receiver maintain no persistent state information about the communication session. Each transmitted packet is handled independently, with the protocol keeping no memory of previous packets. This simplifies protocol design and reduces resource consumption on endpoints.

• Consequence: The receiver cannot natively detect duplicate or out-of-order packets without application-layer logic.
• Trade-off: Enables faster processing but shifts reliability concerns to the application.

Connectionless transport headers are significantly smaller than their connection-oriented counterparts. For example, a UDP header is only 8 bytes, compared to at least 20 bytes for a TCP header. This reduces bandwidth consumption and processing latency.

• Impact: Maximizes the proportion of packet payload dedicated to application data.
• Use Case: Ideal for real-time applications like VoIP and gaming where speed is critical and minor data loss is acceptable.

The protocol provides no built-in mechanisms to guarantee packet delivery, ensure ordering, or control congestion. Packets may be lost, duplicated, or arrive out of sequence. This is a design choice favoring speed and simplicity over absolute reliability.

• Application Responsibility: Features like acknowledgments, retransmissions, and flow control must be implemented at the application layer if required.
• Example: DNS queries use UDP; a simple timeout and retry mechanism handles occasional packet loss.

The stateless, address-centric nature of connectionless transport makes it inherently suitable for one-to-many communication. A single datagram can be sent to multiple destination addresses (multicast) or to all hosts on a network (broadcast).

• Contrast: Connection-oriented protocols like TCP require a separate connection to each recipient, which is inefficient for group communication.
• Primary Use: Service discovery protocols (e.g., DHCP, mDNS) and streaming media distribution.

Blockchain nodes use a gossip protocol to broadcast new transactions and blocks. This is a classic connectionless model where a node sends a message to a random subset of its peers without establishing a persistent connection. This ensures rapid, redundant, and robust propagation of data across the entire network, crucial for achieving consensus and ledger consistency.

• Example: Bitcoin and Ethereum nodes broadcast INV (inventory) and TX messages via UDP-like gossip.

Networks like Ethereum use the Kademlia Distributed Hash Table (DHT) for peer discovery. Nodes send UDP-based PING and FIND_NODE queries to find and connect to other peers. This process is connectionless—each query is a standalone datagram. The DHT allows nodes to build a decentralized map of the network without maintaining long-lived connections to a central directory.

Light clients, such as Ethereum's Les clients, often use connectionless requests to full nodes. They can send a single query (e.g., for a specific account balance or transaction receipt) via a UDP-based RPC and receive a single response. This minimizes overhead for devices with limited resources, as they don't maintain the persistent TCP connections required by full nodes.

In scalability solutions like optimistic rollups, connectionless principles are key. A verifier can challenge an invalid state transition by broadcasting a compact fraud proof to the network. This proof is a self-contained datagram that any node can independently verify without prior connection state, enabling trust-minimized security.

This highlights where connectionless transport is not used for performance or reliability reasons.

• Block Synchronization: Downloading the full chain uses TCP for reliable, in-order delivery of gigabytes of data.
• Consensus Messaging: Protocols like Tendermint's gRPC (over TCP) for consensus votes require guaranteed, ordered delivery to ensure safety.
• RPC Endpoints: Most user interactions with nodes (e.g., MetaMask to Infura) use HTTP/WebSockets (TCP-based) for reliable request/response flows.

A datagram is a basic transfer unit associated with a connectionless network. Each datagram is an independent, self-contained packet containing sufficient addressing information (source, destination) to be routed from source to destination without reliance on prior exchanges. In blockchain networks, messages like transaction broadcasts, block headers, and inventory announcements are transmitted as datagrams. Their independence aligns with the decentralized and stateless nature of P2P communication, though they offer no delivery guarantees.

A peer-to-peer (P2P) network is a decentralized architecture where participants (peers) interact directly without a central coordinating server. Blockchain nodes form a P2P network, using connectionless communication protocols to propagate data. Key characteristics include:

• Decentralization: No single point of failure.
• Ad-hoc Connections: Peers connect and disconnect dynamically.
• Gossip Protocol: Data is flooded through the network via a connectionless "gossip" mechanism, where nodes relay messages to their neighbors.

A stateless protocol does not retain session information or transaction state between requests. Each interaction is processed in isolation based solely on the information in the request packet. HTTP/1.0 is a classic example. Connectionless transport is inherently stateless, as each datagram is independent. In blockchain contexts, this means a node processes incoming transaction or block messages without needing to reference a prior "connection" state with the sender, simplifying network logic and reducing resource overhead on nodes.

Fire-and-forget is a communication pattern where a sender transmits a message without expecting an acknowledgment or maintaining state for retransmission. It is the operational model of connectionless protocols like UDP. In blockchain, this pattern is used for broadcasting new transactions—a node sends the transaction to its peers and does not track which peers received it. This increases network throughput and scalability but places the burden of reliability on higher-layer protocols or application logic if guaranteed delivery is required.

A gossip protocol (or epidemic protocol) is a method for disseminating information across a P2P network where nodes periodically exchange data with a random subset of neighbors. It is a decentralized, connectionless broadcast mechanism. In blockchains like Bitcoin and Ethereum, gossip protocols are used to propagate:

• Transactions: New, unconfirmed transactions.
• Blocks: Newly mined blocks.
• Node Addresses: Peer discovery information. This creates a robust and fault-tolerant network despite the unreliable, connectionless underlying transport.