How the TON Blockchain Works: Architecture, Consensus and Sharding

The TON blockchain spreads transaction processing across several coordinated chains. A single masterchain records the network configuration, the current validator set and the latest block hashes of every other chain. Validators selected through proof of stake produce and sign blocks. The basechain, where most accounts and smart contracts live, is divided into shardchains that process transactions in parallel.

This article covers that architecture, how validators reach consensus, how shards split and merge as load changes, and how smart contracts interact by passing messages. It ends with the limits of performance claims: a network's design capacity, its benchmark results and the speed users see in real applications measure different things.

What Is the TON Blockchain?

The TON blockchain is a public network for recording transactions and running smart contracts. In its current form, TON stands for The Open Network, a Proof-of-Stake blockchain secured by independent validators and developed as open-source software.

TON is a Layer 1 blockchain. It keeps its own ledger, its own validator set and its own consensus rules. It does not depend on another chain for security or final settlement. Smart contracts on TON execute on the TON Virtual Machine (TVM).

The name has a history. Telegram began building the original Telegram Open Network in 2018. In 2020, after a legal dispute with the U.S. Securities and Exchange Commission, Telegram withdrew from the project. Independent developers kept working on the open-source code, and the network continued under its current name. Telegram later added TON-based features, such as a wallet integration. Those integrations do not make Telegram the network's operator.

The two names are easy to mix up. TON refers to the blockchain, while Toncoin is the native cryptocurrency used on it.

TON runs many chains inside one protocol. This multi-chain structure is how a single Layer 1 network organizes its work. Shardchains follow the same protocol and consensus as the rest of the network, so they are not separate Layer 2 networks.

To see how this works, you first need to know how the masterchain, workchains and shardchains differ.

TON Architecture: Masterchain, Workchains and Shardchains

The TON blockchain is organised as a hierarchy of chains. The masterchain coordinates the network. Workchains define where accounts live and how their transactions are executed. Shardchains divide a workchain's accounts so that blocks can be produced in parallel. Together these layers make up The Open Network.

The Masterchain

The masterchain, which has workchain identifier -1, stores the network's global configuration. This includes protocol parameters, the current validator set and validator stakes, and other settings that every node must agree on. Each masterchain block also records the hashes of the latest shardchain blocks. Once the masterchain references a shard block, the rest of the network treats that block as final. The masterchain does not re-execute every user transaction. It holds commitments to shard blocks, and the transactions themselves are processed in the shardchains.

Workchains and the Basechain

A workchain is an execution and account domain: a set of accounts that share one address format, one virtual machine and one set of fee and transaction rules. The design allows one workchain's rules to differ from another's. The basechain, with identifier 0, holds ordinary user wallets, Toncoin transfers, jettons (TON's fungible tokens) and most smart contracts running on the TON Virtual Machine (TVM).

The whitepaper allows for many more workchains. At the time of writing, mainnet runs only the masterchain and the basechain, and no other workchain is active. Workchains are secured by the same validators and finalised through the same masterchain, so they should not be treated as Ethereum-style Layer 2 networks.

Shardchains

A shardchain is a subdivision of a workchain. It is responsible for a subset of that workchain's accounts, selected by a prefix of the account address. A shard stays inside its workchain, and its blocks are produced by validator groups drawn from the common validator set. The masterchain is never split or merged the way shardchains are.

Component Responsibility What it should not be confused with
Masterchain Configuration, validator data, finality of shard block hashes A chain that processes every user transaction
Workchain Address format, VM and execution rules for its accounts A Layer 2 that settles to another blockchain
Shardchain Blocks for one address-prefix range inside a workchain An independent network with its own security
Diagram of the TON blockchain architecture showing the masterchain coordinating workchains and their shardchains, secured by Proof-of-Stake validators

How Does the TON Blockchain Consensus Mechanism Work?

Proof of stake and block agreement do separate jobs. Proof of stake decides who may validate and how much weight each validator carries. A Byzantine fault tolerant protocol decides how those validators agree on each block. Since a validator vote in April 2026, mainnet has run Catchain 2.0, a leader-based revision of the protocol. Older Catchain documentation describes the system it replaced.

Proof of Stake and Validator Participation

Validators lock Toncoin in periodic elections run by a system smart contract on the masterchain. Each election picks a validator set and gives every member a weight that the protocol derives from its stake. Selected operators must keep reliable nodes online, check blocks and sign them. Ordinary full nodes download and verify the TON blockchain, but they do not sign blocks. Holders who stake through nominator pools or liquid staking services share rewards and risk, while the pool operator runs the validator.

How Validators Agree on Blocks

The TON blockchain divides the work. Some validators secure the masterchain, and smaller rotating groups drawn from the elected set process individual shardchains. No validator executes every user transaction. In simplified form, a round under the current protocol runs like this:

  1. A designated leader in a validator group proposes a candidate block.
  2. Other group members re-execute its transactions and check the resulting state.
  3. Validators sign valid candidates, and the block is accepted once signatures representing more than two-thirds of the group's total validator weight are collected.
  4. The masterchain records references to accepted shardchain blocks.

Leader rotation, timeouts and recovery rules add detail this outline leaves out.

Byzantine fault tolerance means the group still agrees correctly when some members crash, lie or send conflicting messages. The threshold counts weight rather than headcount: safety assumes faulty validators control less than one-third of total weight.

What Finality Depends On

A block is final when the required weighted signatures exist and the masterchain references it. A wallet notice or exchange credit is a separate application event that depends on how each service reads chain data. Finality holds under two assumptions: honest validators control more than two-thirds of weight, and the network delivers messages within reasonable delays. Validators earn block rewards and fees. Those that go offline or sign invalid data can be fined from their stake, which stays locked for a period after each round so penalties can still apply.

How Does Dynamic Sharding Work in TON?

Inside each workchain of the TON blockchain, responsibility for account states and transaction processing is divided among shardchains. Each shardchain owns a defined slice of the workchain's accounts and executes the transactions that touch them. Because the slices do not overlap, separate shardchains can produce blocks in parallel.

The account address decides where an account lives. A shardchain is identified by a prefix, the opening portion of an address, and every account whose address begins with that prefix belongs to it. Any node can therefore work out which shard holds an account directly from the address.

When Shardchains Split or Merge

In a split, the parent's prefix is extended by one more position, creating two child shardchains. Each child takes the accounts that match its longer prefix. The accounts are partitioned between the two; none is copied into both. A merge reverses the process, combining two sibling shardchains from the same parent once both qualify.

Protocol rules and network configuration govern these changes, including per-workchain split depth limits and block-load thresholds that must hold over a sustained period. A brief burst of traffic does not trigger a split by itself.

A hypothetical case: a popular application concentrates activity in one shard, and its blocks keep nearing their load limits. Once the configured conditions persist long enough, the shard splits and its two halves process their accounts in parallel. Later demand falls, both children stay underloaded, and they become eligible to merge again.

What Sharding Can and Cannot Scale

Distributing independent work raises aggregate capacity, since transactions on unrelated accounts stop competing for space in the same blocks. A single smart contract, however, sits in exactly one shard and its transactions are still processed in sequence there, so a split does not make it run faster. Interactions across shards travel as messages, which adds delivery latency and coordination work.

More shards also mean more blocks to validate, store and propagate. Splitting adds execution capacity, while validator hardware, bandwidth, storage growth and heavily concentrated workloads remain real limits. The "Infinite Sharding Paradigm" in TON's design documents is architectural terminology for how far the partitioning model extends in principle, and it does not describe measured throughput.

Diagram of the TON blockchain architecture showing the masterchain, workchains and shardchains secured by Proof-of-Stake validators

How TON Processes Transactions and Cross-Shard Messages

Accounts, Smart Contracts and Messages

On the TON blockchain, every account has an address, a balance and a state. For a smart contract, that state holds its code and persistent data. Contract code runs in the TON Virtual Machine (TVM), which reads the incoming message and the current state, then calculates the new state and any outgoing messages.

A message and a transaction are different things. A message carries a request to an account, and sometimes value. A transaction is the record of one account processing one incoming message: the computation, the fees, the state changes and the messages it produced. External incoming messages come from outside the blockchain, for example a request signed by a wallet owner. They carry no Toncoin, so the receiving contract must choose to accept them and pay the fees itself. Internal messages travel from one contract to another and can transfer value.

Following a Multi-Step Operation

A common path for a wallet-initiated operation looks like this. Many TON transactions follow other patterns.

  1. The owner signs a request, and it arrives at the wallet contract as an external incoming message.
  2. The wallet contract verifies the signature and sequence number, accepts the message and records the result in its own transaction.
  3. During that transaction's action phase, the wallet emits an internal message addressed to the recipient contract.
  4. The recipient contract processes the internal message in a separate transaction and may emit further messages.

These transactions are separate. They can land in different blocks, and if the accounts sit in different shards, in different shardchains. The full set of linked transactions and messages is called a trace: it starts from the first incoming message and follows every message the operation produces.

TON runs this process asynchronously. Each transaction commits on its own, so a multi-contract operation is not one globally atomic transaction. The wallet's transaction can succeed even when a later step fails. For this reason, checking only the first transaction does not establish the outcome of the whole operation. To confirm the result, inspect the trace through to its final transactions.

When processing fails, the result depends on how the message and contracts were built. If an internal message was sent with the bounce flag set and the recipient's computation fails, a bounce message may return the remaining value to the sender, minus fees. The sending contract still has to handle that bounce correctly. Transactions that already committed earlier in the trace stay in place and are not reversed.

Diagram of the TON blockchain architecture showing the masterchain, workchains and shardchains secured by Proof-of-Stake validators

TON Performance: What the Numbers Actually Measure

Performance figures for the TON blockchain describe different stages of a transaction's life, and each stage uses its own counting unit. On The Open Network, a transaction is the execution of one smart contract, triggered by one incoming message. An internal message can create further transactions in other contracts, possibly on other shardchains. A completed user action, such as a token transfer reaching a wallet, may need several of these transactions. A count of one unit cannot be converted directly into a count of another.

Throughput, Latency and Finality

Metric What it measures What it does not establish
Throughput (TPS) Transactions processed per second in a defined window How many user actions finish per second
Block interval Time between consecutive shardchain or masterchain blocks When a given message is included
Inclusion latency Delay from submitting an external message to its first transaction appearing in a block Completion of follow-up internal messages
Finality Point at which a block is referenced by the masterchain and treated as irreversible End-to-end application latency, including indexing and interface updates

Benchmarks Versus Mainnet Conditions

A benchmark tells you something only when its conditions are stated: the network environment (private testnet or public mainnet), validator hardware, the number and distribution of validators, the shard configuration, the workload (simple transfers or contract-heavy traffic), the test duration, and whether the count covers transactions, messages, or completed operations. A peak result from a dated record test, including those published or promoted by TON-affiliated organizations, is a claim made under those test conditions. It does not describe sustained mainnet throughput or the rate a specific application can expect. Architectural ceilings, such as the theoretical maximum number of workchains and shards, describe design limits and are not measurements.

Timing figures need the same care. The official documentation includes a Catchain 2.0 upgrade page, and older pages describe earlier timing assumptions. Any block interval or finality figure should be read together with the date and consensus version of its source. Where these conflict, this guide gives no single number.

Where Bottlenecks Remain

Sharding spreads load across many accounts, but a single popular contract still processes its messages one after another. Message chains across contracts and shards add a delivery step at each hop, so faster block production does not make a multi-contract interaction, or a service crediting a deposit, equally fast. Validator resources, growing state storage, indexers, and public RPC endpoints add their own limits, and applications that wait for several confirmations before updating balances add more delay.

A performance claim is useful only when it names the counting unit and states whether it was measured on mainnet over a sustained period under a stated workload.