Viper Messenger

Posts · June 1, 2026

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 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:

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:

How content between two nodes is actually encrypted. The whitepaper describes several modes:

  1. 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.
  2. 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.
  3. 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:

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

AspectWeb2 (TLS / PKI)TON (ADNL)
Node identitydomain name256-bit address = SHA-256(public key)
Name ↔ key bindingattested by external CAmathematical (hash), self-certifying
Where encryption livesoverlay (TLS) on top of TCP/IPbuilt into the ADNL network layer
Forward secrecyephemeral ECDHE in TLS handshakeephemeral keys / ECDH per channel
Human-readable namesDNS + CA for keysTON DNS on-chain + Merkle proofs
Trust failure pointCA compromise / misissuancecompromise 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