Summary: ADI Chain’s modular architecture includes key components such as the Sequencer, Prover, Verifier, and Bridge.
The Sequencer forms new blocks on the ADI Chain by ordering and grouping transactions into batches. After each block is created, the Sequencer executes the transactions and updates the network’s state.
The Prover ensures that the data within each block is accurate by generating validity proofs. The validity proofs use zero knowledge (ZK) technology to ensure that the data is accurate without ever having to “see” it, adding a layer of privacy. Once a validity proof is generated, the Prover submits it to the Ethereum L1 for final verification.
The Verifier and the Bridge work together to ensure that assets can flow between ADI Chain and Ethereum in a safe and trustless way. The Verifier is a smart contract on Ethereum that provides final verification for each submitted validity proof, while the Bridge facilitates transfers of assets and messages between Ethereum and ADI Chain.
ADI Network’s software stack is built using a modular zkEVM framework. The L2 node software consists of several components that work in tandem to operate the blockchain and generate proofs. At a high level, the ADI node includes an EVM execution engine, a state database, networking components, a proof generation module, and interfaces to L1.
zkVM Prover: a high-performance zero-knowledge proof system (based on RISC-V and zkSync Airbender) that generates validity proofs for L2 blocks.
Execution Layer (based on the zkSync Stack): a flexible “execution environment” that runs the EVM, whose state transitions the prover will validate.
This architecture allows ADI Network to remain flexible and highly performant in proof generation. The Airbender prover design, in particular, is a game-changer: it’s optimized with advanced STARK/FRI cryptography and AI-designed GPU acceleration to deliver very fast proof times at low cost. In tests, zkVM Prover can produce a full proof of an average Ethereum block in ~30 seconds using a single GPU, and as fast as ~2 seconds for smaller blocks or with parallelization. This ensures that ADI’s batches can be proven and submitted to L1 frequently, keeping latency low. The cost per transaction for proof generation is also negligible (on the order of $0.0001).
Sequencer
The Sequencer is the L2 node component that ingests transactions and orders them into blocks (batches). It is responsible for executing transactions according to this order, updating the L2 state, and producing L2 blocks at a rapid cadence (typically every few seconds). The Sequencer provides users with quick confirmation of their transactions by immediately acknowledging and including them in the next block. This provides the “soft finality” mentioned earlier – a fast, though interim, confirmation that enhances the user experience. The sequencer node in ADI Network aggregates many transactions, compresses them, and prepares the data that will later be sent to L1.
To optimize throughput, ADI runs the sequencer in a high-performance mode. The sequencer can produce blocks continuously and bundle them for proof generation without waiting for L1 each time. In periods of high load, it will include as many transactions as possible in each batch and can even pipeline the batches to the prover. The Sequencer in the zkRollup design does not have the power to finalize invalid transactions – it must work in tandem with the prover and L1 verification. However, it operates under an honest-but-curious assumption for ordering: users trust the sequencer to order transactions fairly. ADI Network utilizes a high-availability Sequencer setup, where multiple sequencer nodes run in a cluster with a hot failover mechanism. This ensures that if the primary sequencer fails, a backup takes over within ~0.1 seconds to continue operations. This failover is coordinated via an internal message queue, ensuring continuity of service. The sequencer nodes use a closed network configuration (not exposed to the public Internet) to prevent spam or attacks at the sequencing layer.
Prover (ZK Proof Generator)
The Prover is the component (or set of components) that generates zero-knowledge proofs of the L2 state transitions. After the sequencer produces a batch of transactions and updates the L2 state, the prover takes the execution trace (the detailed computation of all transactions) and runs it through the zkVM circuits. The output is a succinct cryptographic proof that the new state is correct given the previous state and the batch of transactions. In essence, the prover plays the role that “validators” and fraud proofs played in optimistic rollups – but does so proactively and with mathematical certainty rather than reactively.
ADI’s prover is based on Airbender, which is the fastest open-source ZK proving system currently available [zksync.mirror.xyzzksync.mirror.xyz]. Prover uses a STARK-based proof (with FRI commitments) wrapped in a SNARK for succinct on-chain verification. It executes transactions in a ZK-friendly RISC-V virtual machine, but because ADI uses EVM-compatible bytecode, it can prove EVM execution seamlessly. The prover runs through a multi-stage pipeline (witness computation, polynomial commitment, FRI, etc.) to produce the proof. This process is highly optimized for GPUs and parallel processing. Remarkably, Airbender can prove entire Ethereum-sized blocks in tens of seconds on a single GPU, and even sub-second proofs are achieved for smaller block sizes. This means ADI Network can post frequent proofs to L1 without a bottleneck, supporting near real-time finality, especially utilizing an AI-engineered GPU cluster.
Once the prover returns a proof for a batch, that proof (and associated data) is sent to Ethereum for verification. It’s important to note that the prover’s correctness is self-validating. If the prover (or the hardware it runs on) makes a mistake, the resulting proof would fail verification on L1, so the system remains secure. In summary, the Prover is the cryptographic engine of the ADI Network, transforming batched transactions into an irrefutable proof that Ethereum will accept, thereby securing L2 state changes.
L1 Verifier and Bridge Contracts
To connect the L2 with Ethereum, ADI Network relies on a suite of L1 smart contracts deployed on the Ethereum mainnet. Chief among these are the Verifier Contract and the Bridge Contract (often collectively referred to as the “rollup contracts”). The Verifier is a smart contract that holds the verifying key for the zkSNARK and is responsible for checking proofs submitted by the L2. When the ADI Network submits a batch of L2 transactions to L1, it must include the corresponding validity proof. The Verifier contract utilizes proof verification logic to verify the proof's validity. Only if the proof is valid does it update the stored L2 state (usually represented as a state root or latest batch identifier) on Ethereum. This contract thus acts as the gatekeeper, enforcing that no false state updates can be finalized.
The Bridge contract handles the movement of assets and messages between L1 and L2. When a user deposits tokens into ADI, for example, they send them to the Bridge contract on L1, which locks the tokens and emits a message to L2 (recorded in an Inbox) that credits the user’s account on ADI. Conversely, to withdraw, a user triggers a transaction on L2, which burns or locks their L2 tokens and produces a proof that can be relayed to the L1 Outbox. The Bridge contract will then release the corresponding tokens on L1 when it sees a valid proof of the withdrawal included in a finalized L2 batch. In the zkRollup model, this process is highly efficient: as soon as the L2 batch with the withdrawal is proven on L1, the funds can be released – there is no additional waiting period.
Together, the Verifier and Bridge ensure secure cross-chain interaction: users can trustlessly move assets knowing that only valid state transitions will be honored. The on-chain footprint mainly stores data (call data or commitments) and verifying proofs. ADI’s L1 contracts are designed to be standardized and shared if multiple chains exist – for instance, a unified ADI Bridge could handle bridging for a family of ADI Chains, each identified by an ID but using the same gateway on Ethereum. This approach maximizes security and interoperability across the ecosystem.