November 2025 marked a milestone: Aztec’s Ignition Chain went live as the first fully decentralized privacy L2 on Ethereum.
After years of development, we finally have production infrastructure for private smart contracts. Let me break down what Aztec built and why it matters.
What Is Aztec Ignition?
The Basics
- Type: ZK rollup with native privacy
- Consensus: Decentralized sequencer network (not single sequencer)
- Privacy: Encrypted state and private execution by default
- Network: 185+ operators across 5 continents, 3,400+ sequencers
The Funding Event
Aztec raised 19,476 ETH (~$61M) using a novel Continuous Clearing Auction developed with Uniswap Labs. This wasn’t traditional VC funding - it was a public, on-chain fundraise with price discovery.
Technical Architecture
Private Execution Model
[User with Private State] -> [Private Function Call] -> [ZK Proof Generation]
|
[Rollup Aggregates Proofs] -> [Posts to Ethereum]
Unlike public rollups where execution happens on the sequencer, Aztec’s private functions execute locally on user devices. The sequencer only sees proofs, not inputs or state.
The Noir Programming Language
Aztec developed Noir, a Rust-like DSL for writing ZK circuits:
// Noir contract example
#[aztec(private)]
fn transfer(
context: &mut PrivateContext,
from: AztecAddress,
to: AztecAddress,
amount: Field,
) {
// This executes privately on user's device
// Sequencer only sees the proof
let from_balance = storage.balances.at(from);
let to_balance = storage.balances.at(to);
// Verify sender has funds (private check)
assert(from_balance.get() >= amount);
// Update balances (encrypted on-chain)
from_balance.sub(amount);
to_balance.add(amount);
}
Hybrid Public/Private
Aztec supports both private and public functions in the same contract:
#[aztec(private)]
fn private_transfer(...) { /* Only sender knows details */ }
#[aztec(public)]
fn public_transfer(...) { /* Transparent like regular L2 */ }
#[aztec(private)]
fn shield(amount: Field) {
// Move from public to private balance
}
#[aztec(public)]
fn unshield(amount: Field) {
// Move from private to public balance
}
This composability is crucial - you can integrate with public DeFi while maintaining privacy where needed.
The Decentralized Sequencer Network
Why Decentralization Matters
Most rollups have a single sequencer (centralized). Aztec launched with a decentralized network because:
- Censorship resistance: No single party can block your transactions
- Liveness: Network continues even if some sequencers fail
- Privacy: Sequencers can’t correlate your transactions if they don’t control the whole network
How It Works
[User submits encrypted tx]
|
v
[Mempool (encrypted)]
|
v
[Sequencer selection (rotation/auction)]
|
v
[Selected sequencer orders txs (still encrypted)]
|
v
[Proof generation and aggregation]
|
v
[Post to Ethereum L1]
The sequencer network handles ordering and proof aggregation without seeing transaction contents.
ZK-SNARK Implementation Details
Proving System
Aztec uses a custom proving system based on Plonk with several optimizations:
- Ultra-Plonk: Extended constraint system for efficiency
- Turbo-Plonk: Custom gates for common operations
- Recursive proofs: Aggregate many proofs into one
Proving Times
| Operation | Proving Time (client) | Verification (on-chain) |
|---|---|---|
| Simple transfer | ~2 seconds | ~200K gas |
| Complex DeFi | ~5-10 seconds | ~200K gas |
| Batch of 100 txs | N/A | ~200K gas (amortized) |
Client-side proving is the bottleneck, but it’s becoming practical on modern devices.
What You Can Build
1. Private Tokens
#[aztec(private)]
fn confidential_transfer(to: AztecAddress, amount: Field, memo: [u8; 32]) {
// Transfer with encrypted memo
// Only sender and recipient know details
}
2. Private DeFi
#[aztec(private)]
fn swap(input_asset: AssetId, output_asset: AssetId, amount: Field) {
// Swap on private AMM
// Trade details hidden from observers
}
3. Private Voting
#[aztec(private)]
fn vote(proposal_id: Field, choice: Field) {
// Vote privately
// Result can be publicly aggregated
}
Current Limitations
- Proving time: Still seconds per transaction (improving)
- Liquidity: New network, liquidity bootstrapping in progress
- Developer tooling: Maturing rapidly but not as polished as Solidity ecosystem
- Composability with L1: Requires bridging, can’t directly call mainnet contracts
Getting Started
# Install Noir
curl -L https://noirup.dev | bash
noir install
# Create new project
noir new my_private_app
cd my_private_app
# Build and test
noir build
noir test
The developer experience is genuinely good. If you know Rust, Noir feels familiar.
My Assessment
Aztec Ignition is the most significant privacy infrastructure deployment since Tornado Cash. Key advantages:
- Programmable privacy: Not just mixing, but full smart contracts
- Decentralized from launch: No centralized sequencer risk
- Ethereum-aligned: L2 with L1 security guarantees
- Production-ready: Real money, real users, real network
This is what the next generation of privacy looks like. Not privacy coins - privacy platforms.
Who’s already building on Aztec? What are you planning to build?