Sabitlenmiş Tweet
Puffer Preconf
70 posts
Puffer Preconf
@puffer_preconf
Puffer Preconf (by @puffer_finance) is a preconfirmation AVS on @eigencloud, enabling the speed and composability needed for rollups! 🚀
Ethereum Katılım Temmuz 2025
8 Takip Edilen2.4K Takipçiler
Synchronous composability is the architecture.
Puffer Preconf is the trust layer underneath it.
Same-slot interaction across L1 and L2 is what based rollups make structurally possible.
Slashable execution guarantees are what Puffer Preconf makes cryptoeconomically enforced.
One block. Exact state. Real collateral behind every commitment. That is what Puffer Preconf is built for. 🐡
Puffer UniFi 🐡⛓️@puffer_unifi
📖Glossary: Synchronous Composability Real-time interaction across L1 and L2, and between rollups, inside the same block. Two directions. Two mechanisms: • L1 to L2: Signal Service, same-slot message passing, no bridges • L2 to L2: shared Ethereum sequencing root, with state-aware gateways coordinating in the same slot Both require based sequencing and real-time proving to work. Puffer UniFi is built to make both possible: one execution environment across Ethereum-aligned rollups.
English
🧩 Preconf Series #2: Replacing Centralized Sequencer with @Ethereum Validators
Puffer Preconf turns Ethereum validators into a real-time execution engine for rollups, acting as a gateway-based layer between L2 users and Ethereum validators.
Ethereum validators delegate their validators to a gateway, and the gateway checks the lookahead window to see whether any upcoming Ethereum proposers are delegated to it. If so, L2 users can send transactions through the gateway, and the gateway returns signed execution preconfirmations.
Later, when it is time to propose, @Commit_Boost requests the L1 block from the gateway, and the validator proposes that block to Ethereum, including the L2 batch settlement.
This is the mechanism behind Puffer Preconf’s decentralized sequencing model. Unlike the centralized sequencer model used by traditional rollups, it avoids a single point of failure and removes the need to trust one operator to provide the fast path.
And that fast path is not just decentralized, but low latency. By returning signed execution preconfirmations before final L1 settlement, Puffer Preconf can give users sub-100ms execution guarantees, addressing the state latency problem common to both traditional and based rollups.
In short, the gateway provides the fast preconf service, validators provide the backing and block proposal, and Ethereum provides final settlement.
The result is that rollups can achieve several things at once: decentralized sequencing, without a centralized operator controlling the fast path; lower state latency through fast execution preconfirmations; stronger Ethereum alignment; and a faster, more credible user experience.
English
Based appchains need two things to work in practice:
1. Speed - users can't wait 12 seconds for a confirmation.
2. Trust - soft promises from a centralized sequencer aren't enough.
Puffer Preconf delivers both.
Ethereum validators sequence. Gateways issue signed execution commitments, slashable if broken. Sub-100ms. No single operator. No soft promises.
Every UniFi based appchain inherits this from day one. That is the foundation UniFi is built on. 🐡
Puffer UniFi 🐡⛓️@puffer_unifi
🏗️ Building UniFi #2: UniFi's Mission UniFi is what makes based appchains truly possible on Ethereum. UniFi is the first based rollup built on this stack - Puffer’s own proof of concept. But the stack is open: any project can spin up its own based appchain and inherit the same sequencing, proving, preconfirmation, and composability guarantees from day one. The focus is clear: enable synchronous composability across L1 <> L2 and L2 <> L2, so liquidity, contracts, and applications can coordinate without becoming isolated silos. Based rollups and based appchains should extend Ethereum, not fragment it. To make that possible, UniFi combines @Puffer_Preconf, a decentralized preconfirmation layer built around gateway delegation from upcoming proposers, targeting sub-10 ms transaction speeds while remaining anchored to Ethereum L1 validators. It also uses multi-TEE provers, with Intel TDX and AMD SEV supporting near real-time, trust-minimized block attestations, with ZK proving in the pipeline. The objective is practical: provide developers with a customizable execution environment on Ethereum where speed, composability, and economic alignment are built in from the start. 📖Learn more: docs-unifi.puffer.fi
English
Scaling is not just about throughput, more TPS, lower fees and faster blocks.
It goes beyond these to even sequencing.
Sequencing is simply the authority to order transactions.
But where that authority sits defines how trustless a system actually is.
Recently, @puffer_preconf answered an important question on who controls ordering?
This is because whoever decides the order of transactions:
• decides which trades go first
• captures MEV
• influences execution outcomes
• ultimately shapes where value flows
That’s why sequencing matters.
—
What Puffer is proposing flips the layers model.
Instead of giving sequencing power to a single entity, they anchor it back to Ethereum validators.
That changes the structure entirely:
• No single sequencer to trust
• Ordering inherits Ethereum’s security
• Same ordering context as L1
• Same block, same state alignment
Now add their execution layer on top:
• Validators hold ordering authority
• Gateways execute within that shared ordering
• Preconfirmations give early, credible execution guarantees
• TEE proofs enforce and verify behavior
This is a concept where four layers have one shared ordering root.
—
This is interesting because once ordering is shared and rooted in Ethereum,
you unlock true synchronous composability.
This way there is no fragmented liquidity across isolated sequencers but coordinated execution across layers that share the same ordering root.
Puffer Preconf@puffer_preconf
📖 Glossary: Sequencing On Puffer Preconf, sequencing is the authority to order L2 transactions during a specific slot window, held by Ethereum validators and delegated to gateways, determining how transactions execute before they are settled on Ethereum.
English
📖 Glossary: Sequencing
On Puffer Preconf, sequencing is the authority to order L2 transactions during a specific slot window, held by Ethereum validators and delegated to gateways, determining how transactions execute before they are settled on Ethereum.
English
Rollups today face a brutal trade-off: speed or decentralization.
Ethereum produces blocks every ~12 seconds, creating L1 latency: users must wait not only for transaction confirmation, but also for credible assurance about how their transaction will actually execute.
Latency is a major bottleneck for both traditional and based rollups built on Ethereum.
Traditional rollups can reduce perceived latency through a centralized sequencer. That solves speed, but not credible state guarantees, while also introducing trust assumptions, centralization risk, and a single point of failure.
Based rollups avoid that separate sequencer and align transaction ordering with Ethereum, but they still inherit Ethereum’s latency.
Puffer Preconf breaks this trade-off.
• For traditional rollups, it replaces trust-based soft confirmations with economically enforced preconfirmations.
• For based rollups, it adds the fast execution layer needed to make Ethereum-aligned sequencing practical.
Ethereum validators preconfirm transactions ahead of the L1 block, reducing latency from ~12 seconds to ~100ms, while preserving Ethereum’s decentralization. This means rollups no longer have to choose between fast UX and trustless infrastructure.
Instead of a single sequencer, validators opt in, restake ETH, and delegate to gateways that provide preconfirmations under a deterministic schedule.
All guarantees are economically enforced. If commitments are not honored, restaked ETH is slashed.
Today, more than ~3.18M ETH secures this system.
Puffer Preconf is the infrastructure rollups have been waiting for. 🐡
English
Programmable money needs programmable guarantees.
Soft confirmations aren’t guarantees. Centralized sequencers aren’t guarantees. “Trust us” isn’t a guarantee.
Slashable execution preconfs are.
Puffer Preconf is the enforcement layer for programmable money. 🐡
Puffer UniFi 🐡⛓️@puffer_unifi
🏗️ Building UniFi #1: Programmable Money Programmable money is only powerful if it’s unified. Ethereum turned money into software. Instead of value just sitting in accounts, ETH and tokens can be used by smart contracts to lend, borrow, swap, collateralize, stream, and settle automatically. Ethereum turned money into software. Instead of value just sitting in accounts, ETH and tokens can be used by smart contracts to lend, borrow, swap, collateralize, stream, and settle automatically. The bottleneck is Ethereum L1 blockspace. As demand grows, L1 can’t run every app’s computation on-chain without gas fees spiking and confirmations slowing down. Rollups solved that by moving execution off-chain while still settling to Ethereum. But rollups also created a new problem: fragmentation. Apps and users spread across many L2s, liquidity gets siloed, and capital doesn’t flow back to L1 as a single shared pool. Bridges become the default UX. Ecosystems turn parallel. UniFi’s answer is based appchains plus native and based rollups that scale execution while staying composable with Ethereum. Appchains pay for L1 data (blobs), share revenue with validators via gateways, and still retain control over order flow. UniFi is for Programmable Money. 🐡
English
@x_ploremarket yes and strongest confirmation on your transactions on Rollups.
English
We are now Puffer Preconf! 🐡
Rollups today still face the same bottlenecks: centralized sequencer trust, soft confirmations without real guarantees, weak economic alignment, and censorship risk.
Puffer Preconf provides sub-10ms execution guarantees, not just promising your transaction lands, but guaranteeing exactly what it does when it lands. Backed by ~$6B in restaked ETH.
⚡ Sub-10ms execution confirmations
💰 Revenue sharing for rollups, not just L1
🔒 Ethereum-level security + slashable guarantees
🌐 Decentralized sequencing, no single point of control
🛡️ Censorship resistance + strong liveness
⚙️ No sequencer overhead
Puffer Preconf unlocks the full potential of Ethereum rollups and based rollups.
English
@puffer_preconf @OchePaul305 The execution guarantees here actually make me confident to move big amounts
English
📖 Glossary: Preconfirmations
In Puffer UniFi AVS, preconfirmations are early, signed commitments about a transaction’s execution, issued by a gateway when it is aligned with upcoming delegated Ethereum proposers, before the transaction is finalized on L1.
Preconfirmations, backed by Ethereum’s security.
English
Make Ethereum rollups decentralized and fast with no surprises. 🐡
English
Preconfirmations, but enforced by Ethereum validators. That’s UniFi AVS. 🐡
Preconfirmations let rollups promise fast execution before an Ethereum block is finalized, but those promises only matter if they’re enforced. UniFi AVS makes preconfirmations credible by having Ethereum validators back them with real ETH at risk, so breaking an execution promise can be slashed.
That’s the difference between “fast because we trust” and “fast because Ethereum enforces it.” 🫡
English
Preconfirmations are easy to promise. Hard to enforce.
UniFi AVS lets restaked Ethereum validators guarantee fast execution with real ETH at risk - if they fail, their ETH gets slashed.
Fast UX, enforced by L1 security and secured by programmable slashing. 🫡
English
Composable rollups need economic alignment and robust security.
UniFi AVS anchors execution guarantees to Ethereum validators with restaked ETH at risk - preserving composability, aligning economics, and reducing the fragmentation that traditional rollup designs introduce. 🐡
English
Puffer Preconf retweetledi
🐡@puffer_unifiAVS
Preconfirmations, powered by Ethereum validators.
UniFi AVS brings trustless guarantees to rollups while unlocking additional yield for validators and pufETH holders.
English
Puffer Preconf retweetledi
Thanks to everyone who tuned in with @EigenCloud, @AmirOnchain, and @DeFiYeti.
We covered the future of rollups, decentralized sequencing, and how @puffer_UniFiAVS enables fast execution with guarantees backed by restaked ETH.
📚 The full summary is now live on our blog:
medium.com/puffer-fi/prec…
English
