Arbitrum AnyTrust vs Rollup: Exclusive, Affordable DA
Arbitrum supports two modes—Rollup and AnyTrust—that run the same execution engine but rely on different data availability guarantees. The difference shapes...
In this article
Arbitrum supports two modes—Rollup and AnyTrust—that run the same execution engine but rely on different data availability guarantees. The difference shapes security, cost, and the kinds of apps that make sense on each. If you’re weighing Nova (AnyTrust) against One (Rollup), you’re really choosing a DA model and its trade-offs.
What “data availability” really secures
Optimistic systems assume transactions are correct unless someone proves fraud. That only works if everyone can fetch the data to recompute state. So DA is the oxygen: it keeps verification alive, preserves exit safety, and defines who you must trust when things go sideways.
Two small scenarios make this concrete. A DeFi protocol needs permissionless exits even during chaos; it can’t afford a dependency on a private group to reveal data. A fast-paced game needs rock-bottom fees for 100,000 tiny moves per hour; it can accept modest trust to keep costs predictable.
Arbitrum Rollup mode: trust-minimized DA on Ethereum
In Rollup mode (used by Arbitrum One), batch data is published to Ethereum. Since Cancun/4844, most rollups use blobs rather than calldata for cheaper DA. Verifiers can always access the bytes on L1, so anyone can reconstruct state, dispute fraud, and exit trustlessly.
The cost is higher because L1 bandwidth is scarce. You’re paying Ethereum to durably publish your batch data. The payoff is the cleanest security story: if Ethereum is honest and live, your data is retrievable and exits work without asking permission from anyone else.
Arbitrum AnyTrust: a committee for cheap DA
AnyTrust (used by Arbitrum Nova) replaces always-on L1 DA with a Data Availability Committee (DAC). The committee attests that it will serve the batch data. The chain posts a succinct certificate to L1 instead of all the bytes, slashing the DA bill.
The name hints at the assumption: you only need any one (or a small threshold) of the committee members to be honest and responsive to retrieve the data. If the committee misbehaves or becomes unavailable, the protocol can fall back by posting the data on L1 so users can keep going—costs spike in that window, but safety holds.
Security models side by side
Both modes inherit Arbitrum’s fraud-proof execution. The split is almost entirely about who guarantees data and under what failure modes you can still exit.
| Dimension | Rollup (Arbitrum One) | AnyTrust (Arbitrum Nova) |
|---|---|---|
| Who guarantees DA? | Ethereum L1 (blobs/calldata) | Data Availability Committee (DAC) attestation |
| Assumption to retrieve data | Ethereum liveness and honesty | At least one honest, responsive DAC member or fallback to L1 |
| Exit safety during stress | Always possible via L1 data | Possible; may require fallback posting or waiting for DAC |
| DA cost per byte | Medium (blobs) to high (calldata) | Low (certificate only; off-chain data serving) |
| Best for | DeFi, high-value assets, permissionless invariants | Games, social, microtransactions, high-throughput low-value flows |
| Failure mode | L1 congestion raises cost but not trust | DAC unavailability triggers L1 fallback; temporary fee spike |
Notice how the guarantees differ at the margin. In Rollup mode, failure on L1 is existential; in AnyTrust, the committee’s availability is the first line of defense and Ethereum is the backstop if they falter.
A quick look at costs with concrete numbers
To anchor the discussion, assume a batch contains 50 KB of transaction data. These are rough figures, but they illustrate scale.
- Rollup with calldata: calldata is expensive; you might see tens of dollars per 50 KB at moderate gas prices.
- Rollup with blobs (EIP-4844): blob gas is cheaper; the same 50 KB can cost a small fraction of calldata—often over 10x cheaper depending on blob market conditions.
- AnyTrust: the L1 post is a succinct certificate; the bulk data is served by the DAC off-chain. L1 costs are dramatically smaller and more stable.
The micro-economics matter for user fees. A social app posting tiny notes can hit sub-cent fees on AnyTrust. A derivatives venue may accept higher per-trade costs on Rollup in exchange for neutral, on-chain recovery paths during adversarial events.
What the fallback really means
AnyTrust chains are designed to avoid holding users hostage if the committee withholds data. If the DAC fails to serve, the sequencer can post the missing data on L1, temporarily behaving like a rollup for those batches. This preserves safety and lets users exit or keep transacting, but fees reflect L1 DA until the DAC resumes normal service.
Practically, this reduces the “trust tax” from existential to operational. You trust the DAC for low-cost routine operation, but the system retains an escape hatch using Ethereum.
Choosing a mode: a simple decision flow
Different apps value different failure properties. Use the checklist below to pressure-test your needs.
- Define asset sensitivity: if worst-case loss is intolerable, favor Rollup.
- Quantify throughput: if you need millions of cheap writes, AnyTrust pays off.
- Model adversaries: if you expect targeted censorship, Rollup’s L1 DA is cleaner.
- Budget for spikes: can users tolerate occasional fee surges during fallback?
- Plan exits: do you require permissionless, always-on exits without third-party responses?
Teams often start on AnyTrust to hit cost targets, then graduate parts of their system to Rollup or L1 for critical assets while leaving high-chatter features on the cheaper rail.
Practical implications for developers and users
For developers, the execution stack is the same Nitro environment. The main differences are in how you account for DA costs, how you communicate trust to users, and how you design incident response when the DAC is degraded.
For users, the visible differences are fee levels and the trust banner. A wallet might label Nova as “committee-assisted DA” and One as “L1 DA,” guiding power users who care about exit guarantees during black-swan events.
Common misconceptions to clear up
A few points trip people up when comparing the two modes. Clearing them early avoids wrong mental models.
- AnyTrust does not eliminate safety: it adds a committee for efficiency but keeps an L1 fallback.
- Rollup costs are not static: with 4844 blobs, DA prices float with blob demand, not just gas.
- Both use fraud proofs: execution integrity is equivalent; DA differs, not the dispute model.
- Sequencer choices are separate: centralization of ordering is a different axis from DA trust.
Think of DA as your “who-can-recover-state” policy. The committee speeds the common case; Ethereum secures the worst case.
A tiny end-to-end example
Imagine a weekend tournament game pushing 2 million actions in 24 hours. On Rollup, even with blobs, DA could dominate costs and user fees rise during L1 congestion. On AnyTrust, the DAC serves data cheaply, keeping fees level; if the DAC hiccups on Sunday night, the chain flips a few batches to L1 posting, fees climb temporarily, and players still own their items and can exit.
Flip the scenario to a lending market during a market crash. A clean, trustless exit path is non-negotiable. Rollup mode keeps DA on Ethereum, so liquidators and users can act with no dependency on a committee’s responsiveness.
Bottom-line guidance without the fluff
If your app handles high-value assets or must preserve adversarial exit guarantees, pick Arbitrum Rollup and budget for blob-era DA costs. If your app is social, gaming, or any workload where fee predictability and scale beat hardline trust minimization, Arbitrum AnyTrust is the right tool—with the comfort that an L1 fallback exists if the DAC stumbles.
Both modes share the same execution engine. Your choice is about who promises the bytes, how much you pay to publish them, and how your system behaves on the worst day of the year.
