Aztec Connect was a Layer 2 privacy solution that functioned as a bridge and batching mechanism. It allowed users to conduct private transactions—where amounts and recipient addresses were concealed—while still interacting with popular public DeFi protocols like Lido, Uniswap, and Curve. This was achieved by aggregating user intents, executing them efficiently on Ethereum's mainnet via a single contract called the Bridge Contract, and then settling the private outcomes back on Aztec's zk-rollup. The core technology was zero-knowledge proofs (ZKPs), specifically zk-SNARKs, which cryptographically verified transactions without revealing underlying data.
Aztec Connect
What is Aztec Connect?
Aztec Connect was a privacy-focused interoperability protocol that enabled private interactions with public decentralized applications (dApps) on Ethereum.
The protocol's architecture relied on a network of bridges, each a smart contract programmed for a specific DeFi protocol's logic. A user would initiate a private transaction on Aztec's rollup, which was then relayed to the appropriate bridge contract on Ethereum. This bridge would batch the transaction with others, execute the public trade or action, and submit a validity proof. This design meant users could privately provide liquidity, swap assets, or earn yield, with the public blockchain only seeing a single, aggregated transaction from the bridge, effectively anonymizing the individual participants.
A key innovation was cost efficiency. By batching hundreds of private actions into a single public Ethereum transaction, Aztec Connect dramatically reduced the gas fee burden for each user, making private DeFi economically viable. Furthermore, it offered composability, as the private assets settled on Aztec's rollup could be used in subsequent, more complex private transactions within the Aztec network, enabling a full suite of confidential financial applications.
Aztec Connect was deprecated in March 2024 as its development team, Aztec Labs, shifted focus to Aztec, a new general-purpose, privacy-focused zk-rollup. While Connect served as a pioneering hybrid privacy model, the new Aztec architecture aims to provide a more flexible and developer-oriented platform for building fully private smart contracts, moving beyond the bridge-based model to native privacy for all on-chain interactions.
How Aztec Connect Works
Aztec Connect is a privacy-focused L2 infrastructure that enables private interactions with public Ethereum DeFi protocols through zero-knowledge proofs.
Aztec Connect is a Layer 2 (L2) privacy infrastructure that allows users to interact with public Ethereum DeFi applications—such as Uniswap, Lido, or Aave—while keeping the details of their transactions private. It functions as a privacy bridge, where user funds are deposited into a smart contract called a rollup processor on the Aztec network. Users can then submit private transactions, which are batched together and proven with zero-knowledge proofs before being settled on Ethereum's Layer 1. This architecture separates the private computation (on Aztec) from the public execution (on mainnet), enabling privacy for actions like swapping or lending.
The core mechanism relies on a client-side proving system. When a user wants to perform a DeFi action, their Aztec wallet locally generates a zero-knowledge proof, known as a ZK-SNARK, that validates the transaction without revealing the sender, recipient, or amount. These private intents are aggregated into a single batch by a sequencer. The batch proof is then submitted to Ethereum, where the connected DeFi protocol executes the net result of all the batched transactions—for example, a single large trade on Uniswap—while the individual user's involvement remains completely confidential on-chain.
A key component is the bridge contract, a smart contract deployed on Ethereum for each supported DeFi protocol. This contract acts as a trusted intermediary: it receives the aggregated, anonymized instructions from the Aztec rollup processor, interacts with the target protocol (e.g., performing a swap), and returns the resulting assets to the Aztec contract. Users ultimately receive their private notes representing the new asset balance within the Aztec network. This design means public liquidity pools never see individual private users, preserving privacy without requiring protocols to modify their own code.
The final piece is fee abstraction. To maintain privacy, transaction fees are also handled confidentially. Users pay fees in the asset they are transacting with, and these fees are aggregated and paid by the bridge contract in the public settlement. This prevents fee payment from becoming a privacy leak. Aztec Connect demonstrated a scalable model for private DeFi, though the original Aztec Connect system was deprecated in March 2024 with the launch of Aztec 3.0, which introduced a fully programmable, general-purpose zkRollup for private smart contracts.
Key Features of Aztec Connect
Aztec Connect is a privacy-preserving bridge that allows users to access DeFi liquidity on Ethereum from within the Aztec zk-rollup, shielding transaction details.
Rollup-to-Rollup Bridge
Aztec Connect functions as a bridge between the Aztec zk-rollup and Ethereum L1. It batches private transactions from the rollup, executes them via a bridge contract on Ethereum, and returns the shielded results. This architecture separates private computation from public execution.
- Privacy Layer: User activity and balances remain confidential within the Aztec rollup.
- Liquidity Layer: All DeFi interactions (swaps, lending) occur on Ethereum, tapping into its deep liquidity pools.
Defi Bridge Contracts
The system uses specialized, audited smart contracts on Ethereum called Defi Bridges. Each bridge is custom-built for a specific protocol (e.g., Lido, Uniswap, Aave) and handles the logic for depositing, executing, and withdrawing funds on the user's behalf.
- Single Interaction Point: Users interact with one Aztec contract, which routes to the appropriate bridge.
- Gas Efficiency: Bridges use batch processing and optimized logic to minimize the cost of L1 operations for all users.
ZK-SNARK Proof Aggregation
To maintain privacy, all transactions from the Aztec rollup are proven with ZK-SNARKs (Zero-Knowledge Succinct Non-Interactive Arguments of Knowledge). The system aggregates many private actions into a single, efficient proof.
- Data Compression: A proof can validate hundreds of transactions, compressing them into a tiny cryptographic footprint.
- Validity Proof: The proof is verified on Ethereum, ensuring all bridged transactions are valid without revealing any underlying data.
Unspent Transaction Output (UTXO) Model
Aztec's rollup uses a UTXO model (like Bitcoin) for its private state, rather than an account-based model. Each private note represents a discrete amount of a token owned by a user, with its ownership encrypted.
- Note Commitment: Spending a note requires proving knowledge of a secret nullifier to prevent double-spends, without revealing which note was spent.
- Selective Privacy: Users can choose to keep transactions private or make them public, providing flexibility.
Fee Abstraction & Subsidization
Aztec Connect abstracts the complexity of paying Ethereum gas fees. Users pay fees in the token they are transacting with, and a relayer network can subsidize or batch transactions to improve the user experience.
- No ETH Required: Users don't need to hold ETH for gas; fees are paid from the shielded transaction itself.
- Relayer Role: Third-party relayers can submit transaction batches to L1, paying the gas upfront and being reimbursed from the batch.
Ethereum Composability
A core design goal is seamless composability with existing Ethereum DeFi. Aztec Connect does not create a separate, isolated DeFi ecosystem but acts as a privacy gateway to the established one.
- Protocol Integration: It connects directly to major protocols like Lido (stETH), Element Finance (yield tokens), and Uniswap (swaps).
- Capital Efficiency: Users benefit from Ethereum's liquidity and yields while adding a privacy layer, without fragmenting capital.
Protocols & Ecosystem Usage
Aztec Connect was a privacy-focused bridge that allowed users to interact with public Ethereum DeFi protocols through private, shielded transactions.
Privacy-Preserving Bridge
Aztec Connect was a layer 2 rollup that enabled private interactions with public Ethereum protocols. It functioned as a bridge and batching layer, aggregating user intents to execute them on Ethereum mainnet while keeping user identities and amounts confidential.
- Core Mechanism: Users deposited funds into the Aztec rollup, generating private notes. They could then submit private proofs to request interactions (e.g., a swap) with a connected mainnet DeFi protocol like Lido or Uniswap.
- Bridge Contract: A single, permissionless Ethereum smart contract (the 'Bridge') managed the logic for each integrated protocol, receiving batch transactions from the Aztec sequencer.
ZK-SNARKs & Private State
Privacy was achieved through zero-knowledge proofs (ZK-SNARKs) and a private state model.
- Private Notes: User balances were represented as encrypted commitments on-chain, only decryptable by the note owner.
- Proof Generation: To transact, users generated a ZK-SNARK proof locally. This proof verified that the user owned the input notes and knew the transaction details, without revealing them.
- State Transition: The rollup's validity proof ensured the entire batch of private transactions was correct, updating the private state root without leaking individual data.
Defi Integration Examples
Aztec Connect integrated with major Ethereum protocols to enable private DeFi operations. Key examples included:
- Lido: Private staking of ETH to receive shielded stETH.
- Uniswap & Curve: Private token swaps and liquidity provision.
- Element Finance: Private access to fixed-yield products.
- Aave & Compound: Private lending and borrowing (via credit delegation).
Each integration required a custom Bridge Contract to translate private user intents into valid public Ethereum calls.
Rollup Architecture & Flow
The system's architecture separated private computation from public execution.
- User Client: Generates a private proof for a DeFi action and submits it to the Sequencer.
- Sequencer: Aggregates proofs from many users into a single rollup block and generates a validity proof.
- Bridge Contract: On Ethereum, executes the aggregated, batched transaction (e.g., swapping 1000 ETH total for DAI).
- Settlement: The bridge returns funds to the rollup contract, which privately credits the users' new notes based on their individual proofs. This batch processing dramatically reduced gas costs per user.
Sunset & Distinction from Aztec
Aztec Connect was sunset in March 2024. It is distinct from the current Aztec protocol, which is developing a fully-featured, general-purpose zkRollup for private smart contracts.
- Aztec Connect: Was an application-specific zkRollup bridge focused on private DeFi access. Its codebase is now archived.
- Aztec (the protocol): Is building a decentralized privacy network where developers can write private smart contracts in Noir, a ZK domain-specific language. This represents a broader vision for programmable privacy.
Key Cryptographic Primitives
The protocol relied on several advanced cryptographic constructs to ensure security and privacy.
- PLONK: The zero-knowledge proof system used for efficient proof generation and verification.
- Pedersen Commitments: Used to create the private note commitments that represented encrypted balances on-chain.
- Nullifiers: Prevented double-spending of private notes. When a note was spent, its unique nullifier was published, proving it was consumed without revealing which note it was.
- Viewing Keys: Allowable encryption method that let users share read-access to their transaction history with designated parties.
Aztec Connect vs. Other Privacy Solutions
A technical comparison of privacy-preserving mechanisms, focusing on architectural approach, privacy guarantees, and developer integration.
| Feature / Metric | Aztec Connect | zk-SNARKs (e.g., Zcash) | Mixers (e.g., Tornado Cash) |
|---|---|---|---|
Core Privacy Mechanism | Private function execution via zk-zkRollup | zk-SNARKs on a base layer | Non-custodial smart contract mixing |
Privacy Set | Entire rollup user set | Shielded pool participants | Specific mixing pool (e.g., 1 ETH) |
On-Chain Privacy Guarantee | Full transaction privacy | Shielded transaction privacy | Source/destination unlinkability |
Off-Chain Computation | zkRollup sequencer & prover | Prover (user or service) | None (on-chain deposit/withdraw) |
Developer Integration | SDK for L1 DApp integration | New shielded application required | Interface with mixer contract |
Gas Fee Efficiency | Amortized across rollup batch | High per-transaction cost | Fixed cost per mix cycle |
Ethereum L1 Footprint | Single proof per batch (~0.5 MB) | Proof per private transaction (~0.2 KB) | Two transactions per user (in/out) |
Native Smart Contract Composability | Yes, via L1 bridge contracts | Limited, within shielded pool | No, isolated asset pools |
Aztec Connect
Aztec Connect was a privacy-focused interoperability protocol that allowed users to access decentralized finance (DeFi) applications on Ethereum while shielding their transaction details and asset holdings.
Aztec Connect was a Layer 2 privacy solution built on Ethereum that functioned as a bridge between private transactions and public DeFi protocols. It utilized zero-knowledge proofs, specifically zk-SNARKs, to enable users to interact with applications like Lido, Uniswap, and Curve through a single, private transaction. The core innovation was its rollup architecture, which aggregated many private actions into a single, verifiable proof that was settled on the Ethereum mainnet, significantly reducing gas costs while maintaining privacy.
The protocol's architecture was built around two main components: the Aztec Connect Bridge and the Aztec Network. A user would deposit funds into a bridge contract for a specific DeFi protocol. The Aztec Network's zk-rollup would then batch user intents—such as a private swap or private yield generation—and generate a succinct proof. This proof, when submitted to Ethereum, only revealed the net result of the aggregated transactions (e.g., total assets moved), not the individual user's actions or balances, effectively creating a privacy layer over existing DeFi.
A key technical feature was its use of Efficient Private Delegation. Users did not need to generate their own complex zk-SNARK proofs, which is computationally expensive. Instead, they submitted a simpler proof of intent to a network of proof relayers, who would aggregate transactions and generate the final rollup proof for a fee. This design made private DeFi interactions practical and gas-efficient for end-users, as they only paid for their share of the aggregated batch cost.
While Aztec Connect was sunset in March 2024 to make way for the full Aztec zkRollup, it served as a critical proof-of-concept for privacy-preserving interoperability. Its legacy demonstrates a working model for how confidential transactions can be integrated with the existing, transparent DeFi ecosystem without requiring protocols to rebuild their infrastructure, paving the way for more sophisticated privacy-preserving smart contract platforms.
Security & Trust Considerations
Aztec Connect is a privacy-focused L2 protocol for Ethereum that enables private transactions for DeFi applications. Its security model relies on a unique combination of zero-knowledge proofs, a centralized sequencer, and a decentralized escape hatch mechanism.
Zero-Knowledge Proofs (ZKPs)
The core privacy mechanism. Aztec uses zk-SNARKs to prove the validity of transactions (e.g., correct balance changes) without revealing sender, recipient, or amount details on-chain. This cryptographic guarantee ensures transaction integrity and privacy are mathematically enforced, not just hidden.
Sequencer Centralization & Censorship
Aztec Connect's architecture used a single, permissioned sequencer to batch and prove private transactions. This created a central point of failure and potential censorship risk. Users had to trust the sequencer operator to include their transactions and not front-run or censor them, a significant deviation from Ethereum's permissionless model.
Escape Hatch Mechanism
To mitigate sequencer risk, Aztec included a decentralized escape hatch. If the sequencer went offline or censored users, anyone could submit a withdrawal request directly to the L1 rollup contract. After a challenge period (typically 24-48 hours), funds could be withdrawn publicly, ensuring users could always reclaim assets, albeit without privacy.
Data Availability & State Validation
As a ZK-Rollup, Aztec posted compressed transaction data and validity proofs to Ethereum L1. This ensured data availability and allowed anyone to verify the chain's state was correct. However, understanding the private state required knowledge of nullifiers (spent notes) to prevent double-spends, adding a layer of complexity for full verification.
Trusted Setup Ceremony
The zk-SNARK circuits powering Aztec required a trusted setup ceremony (Phase 2 Powers of Tau) to generate initial proving keys. While this was a multi-party ceremony designed to minimize trust, its security relied on at least one participant being honest and destroying their toxic waste. This is a common, but notable, trust assumption in older ZK systems.
Bridge & Smart Contract Risk
Interacting with DeFi protocols (e.g., Lido, Uniswap) via Aztec's bridges introduced smart contract risk. Users trusted the correctness and security of the bridge contracts that facilitated private interactions. A bug in a bridge contract could lead to loss of funds, independent of Aztec's core privacy guarantees.
Evolution & Current Status
An overview of Aztec Connect's development, operational lifecycle, and its position within the broader landscape of privacy-focused blockchain infrastructure.
Aztec Connect was a privacy-focused bridging protocol and zk-rollup that operated on the Ethereum mainnet from January 2022 until its official sunset in March 2024. Its core innovation was enabling private interactions with mainstream DeFi applications like Lido, Uniswap, and Curve through a system of zero-knowledge proofs (ZKPs). Users could deposit funds into the Aztec rollup, execute shielded transactions, and then batch their private interactions with external protocols via a network of bridges, all while maintaining confidentiality of their wallet balances and transaction amounts.
The protocol's architecture was built around two key components: the zk.money front-end application for users and a permissionless network of bridges operated by relayers. A bridge was a smart contract that encapsulated the logic for interacting with a specific external DeFi protocol. When a user initiated a private swap or yield action, their encrypted transaction intent was relayed to the appropriate bridge, which would then execute the public trade on the user's behalf. The resulting assets were returned to the user's private note within the Aztec rollup, with the entire flow's validity proven by a ZK-SNARK.
Aztec Connect was ultimately deprecated to make way for Aztec, the team's subsequent and more ambitious project: a fully programmable, privacy-first zk-rollup often referred to as a zk-ZK-Rollup. While Connect provided privacy for specific, pre-defined DeFi actions, the new Aztec network aims to offer general-purpose smart contract privacy. The sunsetting process involved a structured wind-down, allowing users ample time to withdraw funds from the Connect system before its contracts were permanently frozen, marking the conclusion of its successful two-year run as a pioneering privacy solution.
Frequently Asked Questions (FAQ)
Common questions about Aztec Connect, a privacy-focused protocol for accessing DeFi on Ethereum.
Aztec Connect is a privacy-preserving layer-2 protocol that allows users to interact with Ethereum DeFi applications without exposing their transaction details on the public ledger. It works by using zero-knowledge proofs (specifically zk-SNARKs) to create private transactions. Users deposit funds into the Aztec Connect bridge contract, which mints a private, encrypted representation of their balance. They can then submit private proofs to a relayer network, which batches these proofs and executes the requested DeFi interactions (like swaps on Uniswap or lending on Lido) on their behalf. The final state changes are settled on Ethereum with a single, efficient proof, shielding individual user activity.
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.