Validium

What Is a Validium?

A validium is a type of Layer 2 scaling architecture that combines two ideas: validity proofs for computational correctness, and off-chain storage for transaction data. The term was coined to describe systems that look like ZK rollups in every respect except one: where the data lives.

In a ZK rollup, the operator posts both a validity proof and the full transaction data to the Layer 1 chain. This means anyone can reconstruct the rollup's state directly from L1 data, guaranteeing that users can always withdraw their funds. A validium posts only the validity proof and updated state root to L1. The transaction data itself is stored off-chain with a designated set of parties, typically called a Data Availability Committee.

This distinction has major implications. Validiums inherit the computational integrity guarantees of ZK proofs: no invalid state transition can ever be accepted by the L1 contract. But they sacrifice the unconditional withdrawal guarantee that defines a true rollup, because users need access to off-chain data to prove their balances and exit.

How It Works

A validium processes transactions through the same pipeline as a ZK rollup, with one critical divergence at the data publication step:

1. Users submit transactions to the validium operator (sequencer), which batches them for processing
2. The operator executes the transactions off-chain, computing the new state
3. A validity proof (zk-SNARK or zk-STARK) is generated, cryptographically attesting that the state transition is correct
4. The proof and new state root are submitted to a verifier contract on L1
5. Transaction data is distributed to the Data Availability Committee rather than posted on-chain
6. The L1 contract verifies the proof and checks that a quorum of DAC members have signed attestations confirming they received the data

The L1 contract will only accept a state update if both conditions are met: the validity proof checks out, and enough DAC signatures are present. This ensures computational correctness while delegating data storage to the committee.

The Data Availability Committee

The DAC is the defining component that separates a validium from a ZK rollup. Committee members are responsible for storing copies of each batch's transaction data and signing attestations that confirm availability. The L1 contract enforces a quorum requirement: a minimum number of DAC signatures must be present before a state update is accepted.

DAC members are typically known, reputable entities: infrastructure providers, exchanges, or protocol teams with economic or reputational incentives to behave honestly. Some implementations add cryptoeconomic security by requiring DAC members to post bonds that can be slashed for misbehavior.

This model is fundamentally different from posting data on L1, where the entire validator set of the base chain guarantees availability. A DAC is a smaller trust assumption: users trust that at least a quorum of committee members will remain honest and available.

Validity Proofs: The Shared Foundation

Both validiums and ZK rollups use the same zero-knowledge proof technology to guarantee state transition correctness. The L1 verifier contract mathematically confirms that every transaction in the batch was executed correctly, balances were updated properly, and no invalid operation occurred.

This is what makes validiums fundamentally different from systems using fraud proofs (like optimistic rollups). Invalid state transitions are rejected immediately at proof verification time, not after a challenge period. The operator cannot steal funds through invalid computation: only through data withholding, which is a separate concern.

The L2 Design Spectrum

Validiums occupy a specific position in the Layer 2 design space. The spectrum runs from maximal security to maximal scalability:

A volition is a hybrid design where individual users or accounts can choose whether their data is stored on-chain (rollup mode) or off-chain (validium mode). StarkEx introduced this concept with its Volition mode in v4.5, allowing applications to offer both options within the same system.

In January 2024, Vitalik Buterin clarified that L2s posting data to external chains (such as Celestia or Avail) rather than Ethereum L1 are validiums, not rollups. His framework defines a rollup as requiring unconditional security: users must be able to withdraw assets even if all operators collude. This requires L1 data availability, which validiums by definition do not provide.

Key Implementations

StarkEx

Built by StarkWare, StarkEx is the most established validium infrastructure. It uses zk-STARKs for proof generation and offers both rollup and validium deployment modes. Immutable X, a platform focused on NFT trading and gaming, uses StarkEx in validium mode to achieve high throughput with minimal gas costs.

StarkEx's validium mode is particularly well-suited for applications where individual transaction values are low but volume is high: gaming asset transfers, NFT minting, and high-frequency trading. The gas savings from not posting data on-chain make these use cases economically viable.

Polygon CDK

Polygon's Chain Development Kit (CDK) supports validium as a deployment option for application-specific chains. CDK validium chains saw significant adoption growth in early 2025, with $420M in combined TVL added in Q1 2025 and 240% transaction volume growth from Q4 2024 to Q1 2025. Notable CDK validium deployments include OKX X Layer, Astar zkEVM, and Immutable zkEVM.

ZK Stack

Matter Labs' ZK Stack framework supports validium mode with multiple data availability backends, including Avail, Celestia, and EigenDA. The framework defines three maturity stages for validium implementations: Stage 0 uses only the node database for DA, Stage 1 adds an external DA layer without on-chain inclusion proofs, and Stage 2 adds L1 verification of DA layer inclusion.

The related zkPorter concept takes a different approach: rather than a pure validium, it creates a composable system where some accounts use rollup-grade DA (on-chain) while others use validium-grade DA (off-chain, secured by proof-of-stake guardians). Both account types can interact within the same system.

Use Cases

Validiums are best suited for applications where throughput and cost matter more than the strongest possible security guarantees:

• Gaming and NFTs: high-volume, low-value transactions where gas costs would otherwise make operations uneconomical. Immutable X processes millions of NFT trades and mints using StarkEx validium mode.
• High-frequency trading: decentralized exchanges processing many orders per second benefit from validium's throughput (approximately 9,000+ TPS) without incurring per-trade data posting costs.
• Enterprise applications: businesses deploying private or semi-private chains via Polygon CDK can use validium mode for cost-efficient settlement while retaining L1 proof verification.
• Social and messaging applications: platforms generating high volumes of low-stakes transactions can use validium to scale without prohibitive costs.

Why It Matters

The validium design reveals a fundamental tension in blockchain scaling: the cost of data availability. Posting transaction data on L1 is the single largest expense for ZK rollups, accounting for 80-95% of their L1 costs. Validiums demonstrate that removing this requirement unlocks dramatically lower fees, but the security tradeoff is real.

For the broader Layer 2 ecosystem, validiums represent an important point on the design spectrum. Not every application needs rollup-grade security. A gaming platform processing in-game item transfers has different security requirements than a stablecoin payment rail handling high-value transfers. Validiums give builders the option to make that tradeoff explicitly. For a deeper comparison of Layer 2 approaches, see the Bitcoin Layer 2 comparison and the second-layer scaling landscape research.

Risks and Considerations

Data Withholding

The most significant risk is DAC collusion or failure. If committee members withhold transaction data, users cannot generate the Merkle proofs needed to withdraw funds from the L1 contract. The validity proofs guarantee that funds have not been stolen through invalid computation, but users cannot access them: funds become effectively frozen.

This is categorically different from a ZK rollup, where users can always reconstruct state from L1 data and exit unilaterally. In a validium, the ability to exit depends on the DAC remaining honest and operational.

Centralization Concerns

DAC members are typically a small, known set of entities. This introduces a centralization vector that does not exist in rollups. If the DAC is compromised, coerced, or simply shuts down, users face the same data withholding problem. The committee model trades the decentralized guarantees of L1 data posting for the efficiency of a trusted group.

Regulatory and Compliance Uncertainty

As regulators develop frameworks for Layer 2 solutions, the weaker security guarantees of validiums compared to rollups may attract additional scrutiny. Applications handling user funds on validiums should consider whether the committee-dependent exit model aligns with regulatory expectations around custody and asset recovery.

Operator Liveness

Like other L2 designs, validiums rely on operators to submit proofs and process withdrawals. If the operator goes offline, users must rely on emergency mechanisms to exit. The combination of an offline operator and an unavailable DAC represents the worst case: users cannot prove their balances and cannot trigger forced withdrawals.

This glossary entry is for informational purposes only and does not constitute financial or investment advice. Always do your own research before using any protocol or technology.