What the Heck is TON
The Open Network (TON) was designed by Nikolai Durov and the TON Core team. It's simultaneously a blockchain platform and a full peer-to-peer network with its own transport, storage, proxy layer, naming system, and payments. The whitepaper describes TON as a massive distributed "supercomputer" capable of handling millions of transactions per second and hosting arbitrary services — blockchain-related or not.
The key insight about TON's architecture: the network comes first, not the blockchain. The foundation is the network layer (ADNL and the DHT, RLDP, overlays built on top of it), and the blockchain is assembled on top of it — as one service among many, alongside Storage, Proxy, DNS, Services, and Payments. The blockchain physically depends on the network: blocks propagate through it, transaction candidates are gathered via it, validators are discovered through it. Without ADNL/DHT/RLDP, there is no blockchain.
What TON Is Made Of
The whitepaper breaks things down into layers, bottom to top:
- The Open Network — the foundation: the P2P network everything else runs on. Includes ADNL transport, DHT, RLDP reliable delivery protocol, and overlay subnets.
- TON Blockchain — built on top of the network: a multi-chain platform with Turing-complete smart contracts, dynamic sharding, and fast inter-shard message routing.
- TON Storage — distributed file storage (torrent-style, with content hashes anchored on-chain).
- TON Proxy — an anonymizing layer similar to I2P, hiding node IP addresses.
- TON DNS — a mostly on-chain system for human-readable names.
- TON Services — a platform for arbitrary services with formalized interfaces.
- TON Payments — payment channels and instant off-chain transfers (lightning-style).
The Blockchain, Briefly
TON's blockchain is not a single chain — it's a collection of chains. There's one masterchain that stores the protocol config, the validator set, and the latest block hashes of all other chains. Below it: up to 2³² workchains (each with potentially different rules), each splitting into shardchains (up to 2⁶⁰ shards per workchain).
The sharding approach is called the Infinite Sharding Paradigm: conceptually, every account lives in its own "account-chain", and shards are just a way to group them efficiently. Shards split automatically under load and merge back when load drops. Consensus is BFT Proof-of-Stake: validators who posted a stake create and sign blocks, and each block gets signatures from at least two-thirds of the active validator group roughly every 5 seconds.
All data — blocks, state, smart contracts, Merkle proofs — is represented uniformly as a "bag of cells", which makes serialization and verification elegantly consistent.
The Network: ADNL, DHT, RLDP, Overlays
The foundation of the network is ADNL (Abstract Datagram Network Layer). It lets nodes communicate using only 256-bit "abstract network addresses" — the underlying IPv4/IPv6 and UDP ports are hidden behind the abstraction.
On top of ADNL:
- DHT — a Kademlia-style hash table with XOR metric, used to find nodes by address, discover services, locate tunnel entry points, and find torrent peers.
- RLDP — a reliable large-datagram delivery protocol over unreliable ADNL (with FEC codes like RaptorQ). This plays the role of "TCP" in TON, carrying RPC requests, files, and HTTP.
- Overlay networks — subgraphs within ADNL for broadcasting blocks of a specific shard, streaming multicast delivery, etc.
A fun detail from the whitepaper: the MTProto protocol Telegram uses for client-server communication can be wrapped in RLDP — making Telegram a "TON service" that becomes practically unblockable via TON Proxy.
The Cryptography of ADNL: Why Content Between Two Nodes Is Encrypted by Design
This is the most interesting part. In the ordinary internet, encryption (TLS) is a layer bolted on top of unencrypted TCP/IP. In TON, identity and encryption are baked into the lowest network layer itself.
An address is a hash of a public key. The abstract address of a node is a 256-bit number — and it's not the public key itself, but the SHA-256 of a serialized TL object describing the key (in the simplest case: a 4-byte magic prefix plus a 256-bit ECC key — roughly 36 bytes total get hashed). RSA-2048 and other schemes can be used too — the address is always a hash of the key description.
This has two fundamental implications:
- To send something to an address, you need to know its preimage — the actual public key whose hash equals that address. Without the preimage, you can't encrypt a datagram.
- To receive and decrypt a message, you must hold the corresponding private key.
How content between two nodes is actually encrypted. The whitepaper describes several modes:
- Simple: the sender appends their ECC signature and address (or preimage) to the datagram, encrypts everything with the recipient's public key, and puts it in a UDP packet. The first 256 bits of the packet are the recipient's address — so the recipient knows which private key to use for decryption. The sender's identity is only revealed after decryption.
- Efficient (for sustained exchange): the sender's private key and recipient's public key are combined via ECDH (Elliptic Curve Diffie-Hellman) into a shared 256-bit secret; AES keys are derived from it together with a random nonce. Integrity is ensured by appending the plaintext's hash before encryption. The shared secret can be computed once and cached — no heavy elliptic curve operations needed after that.
- Channels: two nodes establish a shared secret (via DH or by agreeing on a random secret), and derive a channel identifier from it plus their addresses. That identifier goes in the first 256 bits of subsequent packets.
The upshot: at the ADNL level, you cannot send a packet without encrypting it with the recipient's key, and you cannot read it without the recipient's private key. Content encryption between two nodes isn't an option or a separate handshake on top of the transport — it's a property of how addressing works. Sender authentication is also built in, via signatures or knowledge of the shared ECDH secret.
Comparison with Web2: Why There Are No Certificate Authorities Here
To understand why TON has no CAs, it helps to remember why they exist in the web.
The Web2 model (TLS + PKI). On the ordinary internet, the identity of a service is a domain name (example.com). A domain name has no mathematical relationship to a cryptographic key — example.com is just a string. So the browser needs a trusted third party to attest: "this public key genuinely belongs to the owner of example.com." That's what a Certificate Authority does: it signs a certificate binding a domain to a key, and the browser verifies the chain of signatures up to a root CA it trusts out of the box. Trust here is external, socio-institutional, and has known weaknesses: CA compromise, misissuance, certificate substitution attacks.
The TON model (address = hash of key). In ADNL, the binding of "identity ↔ key" is not delegated to a third party — it's mathematical: the address is literally derived from the key as its hash. To impersonate a foreign address, an attacker would need to:
- find another public key that produces the same
SHA-256address (preimage attack — computationally infeasible), or - obtain the real owner's private key.
Neither is solved by "issuing a fake certificate". The address is self-certifying: knowing the address, you already know whose key you're encrypting to, and you can verify the preimage. The intermediary role of a CA simply isn't needed — cryptography does the job instead.
What about human-readable names? A fair question: CAs exist in the web precisely because people work with names, not keys. TON solves this with TON DNS — but again, without certificate authorities. Names resolve to addresses through a tree of smart contracts on the blockchain, starting from a "root" DNS contract whose identifier is hardcoded into the client. A light client can ask a full node to resolve a domain and receive the answer together with a Merkle proof — allowing independent verification that the answer is correct and cannot be substituted by an interceptor, unlike classic DNS. Trust in names rests not on a list of trusted CAs, but on blockchain consensus and verifiable Merkle proofs from a known root.
Side by Side
| Aspect | Web2 (TLS / PKI) | TON (ADNL) |
|---|---|---|
| Node identity | domain name | 256-bit address = SHA-256(public key) |
| Name ↔ key binding | attested by external CA | mathematical (hash), self-certifying |
| Where encryption lives | overlay (TLS) on top of TCP/IP | built into the ADNL network layer |
| Forward secrecy | ephemeral ECDHE in TLS handshake | ephemeral keys / ECDH per channel |
| Human-readable names | DNS + CA for keys | TON DNS on-chain + Merkle proofs |
| Trust failure point | CA compromise / misissuance | compromise of node's private key |
The Core Idea
TON is not "yet another blockchain" — it's a blockchain plus a P2P network, designed together to replace the familiar web without central servers. The central cryptographic idea is simple and elegant: a node's address is its key (or rather, the hash of its key). From that single design decision, two properties follow for free — content between two nodes is encrypted by the very nature of addressing, and verifying "who is who" requires no certificate authorities, because the node's identity is guaranteed by mathematics, not by an external institution of trust.
Source: The Open Network whitepaper, Nikolai Durov / TON Core, July 26, 2021.
First published June 1, 2026 on the old Viper Foundation blog; moved here November 19, 2026. All posts