Puffer UniFi Testnet V2 is now live!

The Scaling and UX endgame for dApps.

TLDR

- 10 ms transactions with revenue share to make based, win-win
- Based Appchains replace smart contracts while remaining composable with Ethereum L1
- Pragmatic 2025 roadmap: multi-TEE real-time proving, preconfirmations, bedrock for L1↔L2↔L2 composability
- Economic Solution to Based Sequencing: Rollup devs and L1 proposers share MEV and congestion fees fairly.
- Decentralization roadmap: Puffer ships everything decentralized and permissionless and UniFi is no exception

Introduction

Ethereum’s Layer 1 is hitting its limits for speed, cost, and user experience. To scale without fracturing liquidity or dev communities, we need execution environments that deliver ultra-fast finality, preserve order flow, and stay fully interoperable with the L1.

Institutions struggle to build solutions that scale to millions of users.

Puffer UniFi Based Rollup is set to redefine the application layer on Ethereum by replacing traditional smart contracts with Ethereum Appchains. By leveraging the ultimate shared sequencer (based sequencing), atomic composability, and EIP-7702, Puffer will deliver seamless DevX and UX.

UniFi lets devs keep both order flow and receive a share of the revenue.

What is the current state of programmable money infrastructure?

With the growth of their user base, any L1 blockchain will eventually need to offload some computation or operations off-chain to meet rising demand.

An early solution was rollups (L2s). Their goal was to offer users similar transaction guarantees while reducing cost and increasing speed. Although that wasn’t the original intent, L2s soon began replicating existing L1 applications — effectively creating parallel ecosystems.

However, the absence of real-time proving prevented users from withdrawing assets back to L1, turning rollups into standalone chains and undermining the very purpose of scaling the L1.

L2s have brought many new users and projects into the ecosystem. Unfortunately, they’ve also split attention and liquidity, so users and developers can’t agree on a single “winner” L2. Seeing the revenue rollups generate, more teams copied the model, which deepened the fragmentation.

To address this, Puffer UniFi introduces “based appchains” and “general purpose based rollups” for smart contracts. By preserving the benefits of rollups (and without forgoing their revenue streams), appchains can scale Ethereum while remaining fully composable with it.

This symbiosis enriches Ethereum L1: appchains pay for L1 data (blobs) and share a portion of their income with L1 validators through gateways — yet retain control over their order flow.

Overview of Puffer’s Mission

This document outlines how Puffer UniFi is working towards a pragmatic and incremental approach to launching based rollups and based appchains in 2025, with a focus on:

- Launching in Q2 2025 with a hybrid architecture supporting based rollup features.
- Achieving L1<>L2 and L2<>L2 composability.
- Introducing Phase 1 of preconfirmations, powered by a decentralized Gateway Registry AVS (Puffer Preconf) and Proposer Delegation.
- 10 ms transaction speed
- Employing multi-TEE provers for real-time, trust-minimized block proving. (Intel TDX + AMD SEV)
- Creating a custom execution environment for any developer on Ethereum.

Preconf Gateway Registry AVS on EigenLayer

To remain competitive with existing rollups and continue to grow and scale based rollups, we need preconfs; however, there are challenges with creating a large scale preconf network with enough economic security.

Challenges

Creating a new preconf network can have the following challenges:

- Bootstrapping the Network: No L2 execution-level preconfs are live today, making initial traction difficult. Gateways might need collaterals up to 1000 ETH
- High Slashing Costs: Operators may be wary of high potential penalties in early stages. Given they would have to put down an additional 1 ETH of bond.
- Trust Assumptions: Delegators must initially trust gateways to act honestly and propose preconfirmations without malicious behavior.

Case Study:

Liquid-staking protocols now dominate Ethereum staking. Platforms such as Lido, Coinbase, and Binance control most of the validator set.

To bootstrap a reliable pre-confirmation network that can compete with existing rollups, a large portion of those validators would need to opt in, delegate their rights, and post a bond to the registry contract. Convincing them to take that step is a significant challenge.

EigenLayer’s existing validator set solves the cold-start problem.

Preconf Roadmap

Preconfirmations Timeline

1. Centralized Gateways

The initial setup uses a centralized sequencer model where gateways opt into Puffer’s Preconf AVS.

Already implemented in the upcoming UniFi launch we utilize a gossip protocol for p2p messages.

2. Onboarding More Gateways

Progressive decentralization through the addition of more independent gateways. Additional gateway teams can take advantage of Puffer Preconf AVS to opt into additional rollups.

3. Proposer Delegated Based Sequencing

Enables validator-driven sequencing while maintaining preconfirmation performance.

Preconfirmation (L2 Execution Preconfs)

Why Economic Security?

EigenLayer provides two forms of slashable economic services. One is inspired by the Ethereum validator and staking model, where the full 32 ETH (and even more post-Pectra) is restaked toward an instance. The other version involves restaking custom LSTs or any other ERC-20 tokens as a form of slashable security.

Both of these approaches can be utilized for the Puffer Preconfs. Initially, to enable more seamless adoption, we will utilize the native restaking model to attract validators and delegate their proposal rights to a gateway. This will:

- Remove the need for additional bonds or locked ETH, easing initial adoption.

Rewards Mechanism (Puffer Preconf V1)

- Validators delegate to an EigenPod.
- Validators receive a liveness score to qualify for rewards.
- Rewards are distributed based on this score, encouraging availability and performance.

Phase 1: Registration

- Operators and validators onboard via an opt-in system to participate in the Preconf AVS.

Phase 2: Introduction of Slashing and additional gateways as sequencers

- Redistribution slashing becomes available through EigenLayer mechanisms. (users can be refunded)
- Puffer will begin incorporating slashing in line with AVS advancements.

Phase 3:

- Commit-Boost will be used as the proposer commitment

There is an ongoing effort to handle slashing using universal registry contract. Puffer Preconf is going to be forward compatible with this standard.

Universal Registry Contract (URC)

- URC GitHub Repository
- Enables custom slashing logic via the URC Slasher.
- Puffer’s Preconf AVS will opt into URC-based slashing in Post-Phase 2.

How does it work: If slashing function gets called on an opted in validator, the EigenLayer slashing will be called from the URC.

The Rollup Evolution

First Version

1. OP Stack

The architecture follows Gattaca’s Based OP Stack, enabling better ecosystem alignment and compatibility with evolving L2 standards. Taking advantage of stream of frags, this execution method enables faster preconfs and ultimately a faster chain.

2. Multi-TEE Provers

UniFi incorporates both TDX and AMD SEV in its prover setup, reducing single-vendor trust assumptions.

Running the entire OP stack (both `op-geth` `op-reth` or upcoming clients in the future) inside a TEE allows the system to stay dynamically aligned with upstream client upgrades without compromising attestation or privacy guarantees.

Adopting two or more TEE manufacturers allow for reduced trust and chance of collusion between the manufacturers.

3. Potential Risks

While the manufacturer risk and client dependency is reduced, Liveness is an important factor, for instance, DeFi and Lending apps that require liquidations in realtime on the L1.

To mitigate this economic security can be implemented to guarantee the liveness. (EigenLayer or Symbiotic can be used)

In case of liveness fault of the prover, we will fall back to the fault proof.

Second Version

zk Provers as Fallback

Introducing zk proving for additional integrity guarantees and long-term decentralization. This can be provers already developed by Succinct and Risc Zero for the OP stack.

Enhanced Preconfs

Upgrades based on feedback and alignment with the full preconfirmation roadmap.

The gateways should be all delegated from the proposers and become decentralized.

Prover Upgrades

1. The rollup will progressively upgrade toward trustless, real-time proving by combining ZK + TEE-based methods.
2. Upon maturity of Native Rollup technology, the UniFi-based stack will adopt these advances accordingly.

Rollup Architecture

It is note worthy to understand the client architecture of the Gattaca’s OP frags, one should refer to https://gattaca-com.github.io/based-op/.

We implemented modifications to enable multi-tee prover along with atomic withdrawals.

Here is the flow of an atomic transaction within one block:

The rollup will submit the blob

1. User bridges funds to the UniFi bridge from the Ethereum Mainnet
2. After performing transactions on the rollup user or dApp requests a withdraw to L1
3. The rollup will submit the state proof
4. Upon approval of the state proof in both TEE environments the funds will be released back to the L1

How Does the Prover Work

Historically, the use of Trusted Execution Environments (TEEs) has been considered risky in the context of trustless or decentralized applications for two main reasons:

- Potential for malicious actions, including side-channel attacks.
- The inherent trust assumption in the hardware manufacturer.

While one could argue that many critical human-operated infrastructures rely on manufacturer trust, we aim to mitigate this concern by aggregating proofs from two or three different TEE manufacturers, while also running multiple execution clients. This approach significantly enhances the system’s integrity and reduces the likelihood of collusion.

Below is an example of user flow for withdrawal request.

Why Choose Puffer UniFi as an Institution or Application Developer

Instead of simply deploying a smart contract on Ethereum L1, consider launching your own appchain. This allows you to scale without limits and fully customize the environment to suit your needs:

1. Orderflow is King

Orderflow is king — and by running UniFi, you’re part of the supply side, not just the demand. This opens up new economic opportunities and execution control.

2. Control Over Transaction Fees

Gain full flexibility in how transaction fees are structured, distributed, or even subsidized.

3. Customized Access Control

As an institution, you can enforce KYC/KYB requirements to access your environment.

As a permissionless developer, you can allow open participation and have a governance free application.

4. Speed

With our preconfirmations (preconfs) service, we are targeting sub-10ms transaction finality, enabling ultra-fast user experiences.

5. Tailored Data Availability (DA) Layer

Choose or design your own DA layer optimized for your app’s specific needs.

6. Seamless Integration with L1 Capital and Users

Puffer UniFi supports EIP-7702 and atomic withdrawals, simplifying appchain deployment and interaction with other Ethereum-native protocols.

7. Governance free rollups:

The ability to introduce governance-minimized rollups, made possible by being based.

8. L2<>L2 and L2<>L1 real-time interoperability

Case Study

In today’s appchain landscape — exemplified by platforms like Hyperliquid — integrating a third-party bridge is essential for enabling instant withdrawals and tapping into Ethereum mainnet liquidity.

In general purpose chain models such as Converge, the value proposition is KYC-compliant DeFi, but this comes at the expense of forfeiting orderflow. Large asset managers (for example, a firm with $6 trillion in AUM like Fidelity) can easily complete KYC and deploy their own custom execution environments — i.e., appchains — with a host of bespoke features.

Users and big ETH holders are far more inclined to provide liquidity when they trust that exit mechanisms are both fast and flexible.

Accordingly, the primary KPI for an execution environment will shift from total value secured to transaction volume. High-frequency order flow and innovations like onchain CLOB is the real revenue driver for appchains.

Conclusion

Custom execution environments of Puffer UniFi can take one of the following forms:

Each has its own use cases depending on the user base and the developers. Their speed and flexibility make it easy to support future integrations — such as AI-oriented development and AI-guided user access.

Based appchains are the ultimate form of accessibility and scale for users.

About Puffer Finance

Puffer Finance is a leading innovator in Ethereum infrastructure, focusing on next-generation rollups supported by liquid restaking (LRT) and preconfirmation as an AVS. With products like Puffer UniFi and Puffer UniFi AVS on EigenLayer, we are dedicated to enhancing Ethereum’s decentralization. Visitpuffer.fi for more information.