Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
Free 30-min Web3 Consultation
Book Consultation
Smart Contract Security Audits
View Audit Services
Custom DeFi Protocol Development
Explore DeFi
Full-Stack Web3 dApp Development
View App Services
LABS
Glossary

Aztec

Aztec is a privacy-focused zk-rollup network for Ethereum that enables private smart contracts and confidential transactions using zero-knowledge proofs.
Chainscore © 2026
definition
BLOCKCHAIN PROTOCOL

What is Aztec?

Aztec is a privacy-focused Layer 2 scaling network for Ethereum that uses zero-knowledge proofs to enable confidential transactions and smart contracts.

Aztec is a ZK-Rollup protocol built on Ethereum that provides programmable privacy for decentralized applications (dApps). Unlike standard Layer 2 solutions that only scale transactions, Aztec uses advanced zero-knowledge cryptography, specifically ZK-SNARKs, to encrypt transaction amounts and participant identities on-chain. This allows users to transfer assets and execute complex logic within smart contracts without revealing sensitive financial data to the public ledger, a core feature known as private computation.

The protocol's architecture is built around two main transaction types: private and public. Private transactions are fully shielded, obscuring sender, receiver, and amount, and are settled in a private state tree. Public transactions are transparent and compatible with standard Ethereum smart contracts. A critical innovation is Aztec Connect, a bridge system that lets users interact with mainstream DeFi protocols like Lido or Uniswap directly from a private account, enabling private yield farming and swaps by batching private user intents into a single public contract call.

Key technical components include the PLONK proof system for efficient proof generation and the Noir domain-specific language (DSL), which allows developers to write privacy-preserving smart contracts. By leveraging ZK-Rollup technology, Aztec also provides scaling benefits by bundling hundreds of private transactions into a single cryptographic proof submitted to Ethereum Layer 1, significantly reducing gas costs per transaction compared to executing privacy operations directly on the mainnet.

Aztec addresses a fundamental gap in blockchain transparency by enabling confidential DeFi and payments. Use cases include private payroll, discreet corporate treasury management, and shielding individual trading strategies from public analysis. As a Layer 2, it inherits Ethereum's security while offering a specialized execution environment for privacy, positioning it as a critical infrastructure for users and institutions requiring financial confidentiality on a public blockchain.

how-it-works
PRIVACY-FIRST ARCHITECTURE

How Aztec Works

Aztec is a privacy-focused Ethereum Layer 2 network that uses zero-knowledge cryptography to enable private smart contracts and confidential transactions.

At its core, Aztec operates as a zk-rollup, a Layer 2 scaling solution that batches hundreds of transactions off-chain and submits a single cryptographic proof—a zk-SNARK—to the Ethereum mainnet for verification. This architecture provides scalability by reducing on-chain data and computation, while the zero-knowledge proofs ensure the validity of the batched transactions without revealing their contents. Unlike standard rollups, Aztec's primary innovation is extending this privacy to the transaction data itself, allowing amounts and participant identities to remain hidden.

User privacy is achieved through a dual-note system. Funds are represented as encrypted notes stored in a private data tree. To transact, a user creates a zero-knowledge proof that demonstrates they own the input notes, know the transaction's validity conditions, and can generate the correct output notes—all without revealing the notes' values or the links between them. This process is managed by Aztec's domain-specific language, Noir, which allows developers to write private smart contract logic that compiles into these verifiable zk-SNARK circuits.

The network distinguishes between public and private state. The public state is visible on-chain and handles functions like proving rollup validity and managing public smart contracts. The private state, consisting of encrypted notes, is stored off-chain by users and sequencers. A user's ability to spend is proven via zk-SNARKs, not by revealing a private key on-chain. This separation allows for complex DeFi interactions—like private lending or trading—where financial logic is executed confidentially, with only the essential proof of correctness being published.

Key components enabling this system include the Aztec Sandbox for local development, the Aztec Node (sequencer) for processing transactions, and the Rollup Contract deployed on Ethereum L1. The sequencer collects private transactions, generates the rollup proof, and posts it to mainnet. Users interact with the network through wallets like the Aztec Wallet SDK, which handles note management and proof generation locally, ensuring private keys and sensitive data never leave the user's device.

Aztec's approach contrasts with mixing-based privacy systems by providing programmable privacy integrated at the smart contract layer. This enables new use cases such as confidential voting in DAOs, private payroll, and stealth airdrops. By leveraging succinct proofs, the system maintains strong privacy guarantees—data availability for public data and data privacy for encrypted notes—while inheriting Ethereum's security for settlement and consensus.

key-features
PRIVACY-FOCUSED LAYER 2

Key Features of Aztec

Aztec is an Ethereum Layer 2 network that uses zero-knowledge proofs to enable private smart contracts and confidential transactions.

01

Privacy-First Smart Contracts

Aztec's core innovation is zk-zk-rollups, which combine zero-knowledge proofs with rollup scaling. This allows developers to build private smart contracts where transaction details, amounts, and user identities are encrypted on-chain. Unlike standard rollups, Aztec processes private state transitions, making it a fully private execution environment.

02

ZK-SNARKs & ZK-Circuits

Aztec's privacy is powered by ZK-SNARKs (Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge). Developers write logic in Noir, a domain-specific language for creating zero-knowledge circuits. These circuits prove the validity of private computations without revealing the underlying data, forming the foundation for confidential DeFi and applications.

03

Public & Private State Hybrid

The network manages a dual-state model:

  • Public State: Standard, transparent Ethereum-like balances and contracts.
  • Private State: Encrypted notes stored in user-owned note hash trees, accessible only with a viewing key. This hybrid architecture allows for interoperability between public liquidity and private transactions within a single application.
04

Efficient Private Transactions

Aztec batches private transactions into a single ZK-SNARK proof that is posted to Ethereum L1. This provides:

  • Data compression: Only proof and minimal state changes are published.
  • Cost amortization: High fixed proof costs are shared across many users.
  • Finality: Inherits Ethereum's security upon proof verification.
06

Use Cases & Applications

Aztec enables a new class of private on-chain applications:

  • Private DeFi: Confidential trading, lending, and stablecoin transfers.
  • Private Voting & Governance: On-chain votes with secret ballots.
  • Enterprise Compliance: Auditable private transactions for institutions.
  • Private NFTs & Gaming: Hidden ownership and in-game asset transfers.
technical-components
AZTEC

Core Technical Components

Aztec is a privacy-focused Layer 2 network for Ethereum that uses zero-knowledge proofs to enable private transactions and smart contract execution. Its architecture is built on several core cryptographic and scaling components.

01

ZK-SNARKs

ZK-SNARKs (Zero-Knowledge Succinct Non-Interactive Argument of Knowledge) are the core cryptographic primitive. They allow one party to prove they possess certain information (like a valid transaction) without revealing the information itself. In Aztec, they are used to prove the correctness of private state transitions, enabling confidential transfers and private smart contract logic.

02

Private State & Nullifiers

Aztec maintains a private state represented by notes, which are encrypted data commitments stored off-chain. To prevent double-spending, the network uses nullifiers. When a note is spent, a unique nullifier is published on-chain, proving the note was consumed without revealing which specific note it was. This mechanism ensures privacy with integrity.

03

PLONK Rollup

Aztec operates as a ZK-Rollup, specifically using the PLONK proof system. It batches hundreds of private transactions into a single proof, which is then verified on the Ethereum mainnet. This provides data availability and settlement guarantees from Ethereum while offering significant gas cost savings and transaction privacy for users.

06

Public & Private Function Calls

Aztec's hybrid architecture supports both public and private function calls within a single contract. Public functions update state with transparent logic, while private functions use zero-knowledge proofs to compute over encrypted data. This enables applications with mixed privacy requirements, such as a private vote with a public result.

ecosystem-usage
AZTEC

Ecosystem and Use Cases

Aztec is a privacy-focused Layer 2 network for Ethereum, enabling confidential transactions and programmable privacy through zero-knowledge proofs.

02

ZK-SNARKs & ZK-Rollups

Aztec's core technology stack combines ZK-SNARKs (Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge) with a ZK-Rollup architecture.

  • Privacy: ZK-SNARKs prove transaction validity without revealing sender, receiver, or amount.
  • Scalability: The rollup batches hundreds of private transactions into a single proof, compressing data and reducing Ethereum gas costs.
  • Efficiency: Uses PLONK proof system for universal, upgradeable circuits.
03

Aztec Connect

A bridge protocol that allowed private users to interact with public Ethereum DeFi protocols. Users could deposit funds into Aztec's zk.money rollup and then:

  • Privately swap tokens on Lido, Curve, or Element Finance.
  • Earn yield on shielded assets.
  • Batch transactions to save gas. This architecture demonstrated how privacy layers can interoperate with existing public liquidity.
05

zk.money (zkETH)

Aztec's first flagship application was zk.money, a private rollup for Ethereum assets.

  • Function: Users deposited ETH or DAI to receive a shielded, private version (zkETH, zkDAI).
  • Mechanism: All subsequent transfers of these assets were completely private on-chain.
  • Legacy: It served as the primary user interface and proof-of-concept for Aztec's privacy technology before the network's major protocol upgrades.
06

Fully Homomorphic Encryption (FHE)

Aztec's long-term research explores integrating Fully Homomorphic Encryption with zero-knowledge proofs.

  • Concept: FHE allows computation on encrypted data without decrypting it first.
  • Potential: Could enable private smart contract state, where not just transactions but the internal state and logic of a dApp remain confidential.
  • Vision: This represents a shift from private transactions to fully programmable privacy for complex decentralized applications.
ARCHITECTURE COMPARISON

Aztec vs. Other Privacy Solutions

A technical comparison of privacy-focused blockchain architectures, highlighting core mechanisms and trade-offs.

Feature / MechanismAztec (zk-zk Rollup)Monero (CryptoNote)Zcash (zk-SNARKs)Tornado Cash (Mixing)

Privacy Foundation

Zero-knowledge proofs (zk-SNARKs/zk-STARKs)

Ring signatures + stealth addresses

zk-SNARKs (Sprout, Sapling)

Non-custodial smart contract mixing

Privacy Scope

Full transaction privacy (sender, receiver, amount)

Full transaction privacy (sender, receiver, amount)

Optional privacy (shielded or transparent)

Sender/receiver unlinkability for deposits/withdrawals

On-Chain Data

zk-SNARK validity proof only

All transaction data is public but obfuscated

Transparent or shielded note commitments

Public deposit/withdrawal events

Scalability Approach

zk-Rollup (execution & privacy on L2)

Base layer (L1) with no execution scaling

Base layer (L1) with no execution scaling

Application-layer contract on L1

Programmability

Fully programmable private smart contracts

Limited to private payments

Limited to private payments (ZIP 317)

Single-purpose asset mixing

Trust Assumptions

Trustless (cryptographic security)

Trustless (cryptographic security)

Trusted setup for some parameters (Powers of Tau)

Trustless (cryptographic security)

Gas Cost for Private Tx

Low (amortized L2 cost, ~$0.01 - $0.10)

High (L1 Monero block space)

High for shielded (L1 Zcash block space)

High (L1 Ethereum gas for deposit/withdraw)

Auditability

Private state, public proof of validity

Opaque blockchain, limited auditability

Selective disclosure via viewing keys

Anonymity set visibility, no transaction graph

security-considerations
AZTEC PROTOCOL

Security and Privacy Considerations

Aztec is a privacy-focused Layer 2 network for Ethereum that uses zero-knowledge proofs to enable confidential transactions and smart contract execution. Its security model is built on cryptographic guarantees and decentralized trust assumptions.

04

Privacy Sets & Anonymity

Privacy is not absolute but quantified by the anonymity set—the group of users a transaction could plausibly belong to. In Aztec:

  • Note Encryption: Each transaction output is encrypted to the recipient's key, hiding data on-chain.
  • Balance Privacy: Account balances are never revealed, only proven to be non-negative.
  • Set Size: The anonymity set grows with network usage; low activity can reduce privacy guarantees for specific assets or actions.
06

Sequencer Decentralization & Censorship

As a rollup, Aztec relies on sequencers to order and process transactions. Centralization here poses risks:

  • Censorship Resistance: A centralized sequencer could selectively exclude transactions.
  • Liveness: Network halts if the sequencer fails.
  • Mitigations: The protocol is designed for progressive decentralization, with plans for a decentralized sequencer set and forced inclusion mechanisms via Ethereum L1 to guarantee user exit.
evolution
AZTEC

Evolution and History

Aztec was a pioneering privacy-focused Layer 2 network for Ethereum, built on zero-knowledge proof technology. Its development and eventual sunsetting represent a significant chapter in the evolution of on-chain privacy solutions.

The Aztec Network was a zk-rollup that enabled private transactions and smart contract execution on Ethereum. Launched in 2018, it was one of the first projects to implement a UTXO (Unspent Transaction Output) model with zero-knowledge proofs, specifically zk-SNARKs, to shield transaction amounts and participant identities. This allowed users to transact with confidential assets while still inheriting Ethereum's security. The network's core innovation was Aztec Connect, a bridge system that let users interact with public Ethereum DeFi protocols like Lido and Uniswap privately, a concept known as private DeFi.

Aztec's architecture was built around two types of accounts: public notes for transparent interactions and private notes for confidential state. Its PLONK-based proving system, optimized for efficient private computation, was a key technical contribution to the broader zk-rollup ecosystem. However, the project faced significant challenges, including regulatory uncertainty surrounding privacy tools and the immense engineering complexity of maintaining a general-purpose private zk-rollup. In March 2024, the Aztec Labs team announced the sunsetting of the Aztec Network, citing these hurdles and a strategic pivot.

The legacy of Aztec is profound. Its technology and research, including the Noir domain-specific language for zero-knowledge circuits, continue to influence the field. The team shifted focus to developing Aztec Protocol, an open-source framework for building privacy-preserving applications. While the original network is deprecated, its pioneering work demonstrated the feasibility and demand for sophisticated on-chain privacy, paving the way for next-generation ZK-rollups and fully homomorphic encryption (FHE)-based systems that aim to solve similar problems with different cryptographic trade-offs.

AZTEC

Frequently Asked Questions

Common questions about the Aztec protocol, a privacy-focused Layer 2 network for Ethereum that uses zero-knowledge proofs to enable confidential transactions and smart contracts.

Aztec is a privacy-centric zkRollup Layer 2 network for Ethereum that uses zero-knowledge proofs (ZKPs) to enable confidential transactions and private smart contract execution. It works by bundling private transactions off-chain into a ZK-SNARK proof, which is then posted to Ethereum for verification. This proof validates the correctness of all transactions (like transfers or DeFi interactions) without revealing any sensitive data such as sender, recipient, or amount. Users interact with the network via a private kernel, which generates proofs locally, ensuring financial data remains encrypted and confidential while still inheriting Ethereum's security.

ENQUIRY

Get In Touch
today.

Our experts will offer a free quote and a 30min call to discuss your project.

NDA Protected
24h Response
Directly to Engineering Team
10+
Protocols Shipped
$20M+
TVL Overall
NDA Protected Directly to Engineering Team
Aztec Network: Private zk-Rollup for Ethereum | ChainScore Glossary