Validium

The core differentiator of Validium. Transaction data is stored off-chain by a committee of Data Availability Managers (DAMs) or a Data Availability Committee (DAC). This removes the massive data cost from the base layer, enabling extremely high throughput and low fees.

• Primary Benefit: Drastic reduction in transaction costs compared to storing full data on-chain (like Optimistic Rollups or zkRollups).
• Trade-off: Introduces a trust assumption; users must trust that the committee will not withhold data, preventing proof verification and fund withdrawals.

Every batch of transactions is cryptographically verified using Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge (zk-SNARKs) or zk-STARKs. A single proof is posted to the mainnet (e.g., Ethereum) to attest to the correctness of all transactions in the batch.

• Guarantees: Instant finality and cryptographic security for state transitions, unlike the fraud-proof delay in Optimistic Rollups.
• Result: Funds cannot be stolen by invalid state changes, as the base layer contract only accepts verified proofs.

By moving both computation and data availability off-chain, Validium achieves significant scalability.

• Throughput: Can process 10,000+ Transactions Per Second (TPS), as it is not bottlenecked by base layer block space for data.
• Fees: Transaction costs are minimal, paying only for proof verification and minimal calldata on the mainnet. This is ideal for high-frequency, low-value transactions like gaming or micropayments.

A critical, trusted component in many Validium designs. The DAC is a set of known, reputable entities that sign attestations confirming data is available off-chain.

• Role: They store the transaction data and provide cryptographic signatures (often Data Availability Attestations) that the on-chain verifier checks.
• Security Model: This introduces a permissioned or semi-trusted layer. If a supermajority of the committee is honest and available, the system functions. Examples include early implementations of StarkEx (StarkWare) in Validium mode.

A safety mechanism to protect users if the Data Availability Committee fails. If a user suspects data is being withheld, they can initiate a Forced Exit or Escape Hatch.

• Process: The user submits a request directly to the mainnet contract, often requiring a challenge period (e.g., several days).
• Requirement: The user must locally possess the Merkle proof of their funds, highlighting the need for users or their wallet providers to track off-chain data.

Validium is often offered as one option within a Volition architecture, pioneered by StarkWare. A Volition lets users choose per transaction between:

• Validium Mode: For low-cost, high-speed trades (data off-chain).
• zkRollup Mode: For high-value transactions requiring maximum security (data on-chain).

This hybrid approach, used by platforms like Immutable X and dYdX (v3), provides flexibility, balancing cost and security based on user needs.

Validium enables sub-second transaction finality with minimal fees, which is critical for automated market makers (AMMs), perpetual futures, and lending protocols where latency and cost directly impact profitability. The off-chain data layer removes the primary scalability constraint, allowing for complex financial operations that would be prohibitively expensive on a base layer.

• Example: A decentralized exchange can batch thousands of swaps into a single proof.
• Benefit: Users experience near-instant trades with fees measured in cents.

Businesses can leverage Validium for private, auditable transactions and asset tracking without exposing sensitive commercial data on a public ledger. The zero-knowledge proofs provide cryptographic proof of state transitions (e.g., inventory changes, compliance checks) while keeping the underlying data confidential between permissioned parties.

• Key Feature: Data privacy with public verifiability.
• Use Case: A consortium of manufacturers tracking parts through a supply chain, proving authenticity without revealing volumes or partners.

Web3 games and social platforms require the capacity for millions of micro-transactions (NFT mints, in-game item trades, social tipping) without congesting the network or imposing high fees on users. Validium's scalability supports highly interactive, stateful applications with a seamless user experience.

• Requirement: Sustained, high transaction throughput (10k+ TPS).
• Benefit: Players can trade assets freely without transaction fees dictating gameplay.

While the proof is public, the transaction data is not. This makes Validium ideal for applications where transaction amounts and participant identities must be shielded, but the integrity of the system must be publicly verifiable. It offers stronger privacy guarantees than a transparent rollup.

• Contrast with Rollups: Unlike Optimistic or ZK-Rollups, transaction details are never published to the base layer.
• Example: Private voting mechanisms or confidential payroll systems on-chain.

Tokenizing securities, real estate, or commodities often involves handling sensitive investor data and complying with regulations. Validium allows issuers to manage permissioned access and regulatory compliance off-chain while using the blockchain for immutable settlement and proof of ownership. The high throughput supports secondary market trading.

• Key Driver: Balancing transparency for auditors with confidentiality for participants.
• Mechanism: KYC/AML checks can be performed off-chain, with only proof of compliance posted.

A Layer 2 scaling solution that bundles transactions and posts a cryptographic validity proof (SNARK/STARK) to the mainnet, while keeping all transaction data on-chain. This is the core technology Validium modifies by moving data availability off-chain, trading some security for higher throughput and lower cost.

• On-Chain Data: All transaction data is posted to Layer 1.
• Security Model: Inherits Ethereum's data availability and censorship resistance.
• Example: zkSync Era, StarkNet (in its default mode).

The guarantee that the data needed to reconstruct a blockchain's state is published and accessible to all network participants. It is a critical security property.

• On-Chain DA: Data is stored on the base layer (e.g., Ethereum).
• Off-Chain DA: Data is stored by a separate committee or system, introducing a trust assumption.
• DA Problem: If data is unavailable, users cannot prove fraud or withdraw assets, which is the core trade-off in Validium.

A hybrid architecture that gives users a choice per transaction between zk-Rollup (data on-chain) and Validium (data off-chain) modes. This balances security and cost based on the transaction's value and sensitivity.

• User Choice: Select security model for each asset or transaction.
• Flexible Security: High-value transfers use on-chain DA; high-volume, low-value activity uses off-chain DA.
• Implementation: Pioneered by StarkWare's StarkEx platform.

A set of trusted, known entities responsible for storing and providing transaction data in off-chain data availability solutions like Validium. Users must trust that a majority of the committee is honest and available.

• Role: Sign attestations that data is available upon request.
• Trust Assumption: Replaces the trustless security of on-chain data.
• Members: Often includes reputable institutions or the project's core developers.

A Layer 2 scaling solution that assumes transactions are valid by default and uses a fraud proof mechanism with a challenge period to dispute invalid state transitions. All transaction data is posted on-chain.

• Security Mechanism: Fraud proofs with a 7-day challenge window.
• Data Availability: All data is on-chain (like zk-Rollups).
• Key Difference vs. Validium: Uses cryptographic fraud proofs instead of validity proofs, but shares the on-chain DA model that Validium abandons.

The two primary types of zero-knowledge proofs used to generate validity proofs in zk-Rollups and Validiums.

• STARKs (Scalable Transparent ARguments of Knowledge): Do not require a trusted setup; larger proof sizes but faster verification. Used by StarkWare.
• SNARKs (Succinct Non-interactive ARguments of Knowledge): Require a trusted setup ceremony; smaller proof sizes. Used by zkSync, Polygon zkEVM.
• Function: Both cryptographically prove the correctness of a batch of transactions without revealing their details.