Ethereum has a gas limit. But can we mathematically prove the maximum computational work required to verify any valid block? Surprisingly, we don't yet have a certified finite upper bound for the full challenge model. That's the problem @yukonresearch, @zksecurityXYZ, and @Veritylab are tackling with https://t.co/w9Ti86Tqsj. Today, Ethereum validators independently execute transactions to verify blocks. As Ethereum moves toward zkEVM-based validation, the challenge extends beyond executing transactions correctly. We also need to understand the worst-case computational cost. Why does this matter? An Ethereum block could be valid and still require unusually expensive computation. If proving costs become unpredictable, real-time ZK proving could become a bottleneck for Ethereum scaling. https://t.co/w9Ti86Tqsj introduces an open competition to establish mathematically certified upper bounds on block-validation computation. The implications are significant: → More predictable execution and proving workloads. → Stronger foundations for real-time ZK proving. → Greater confidence in raising Ethereum's gas limits. → A path toward validation on more accessible hardware. Of course, bounding execution steps doesn't automatically guarantee fast ZK proofs. But it's an important foundation. Ethereum's next scaling challenge isn't just making execution faster. It's making the worst-case computational cost predictable and provable. And as Ethereum rollups like @puffer_unifi push toward lower latency and synchronous composability, this kind of research becomes increasingly relevant. https://t.co/SwPS2w3ic1

A single Ethereum block reorg caused THORChain to pause swaps involving 10 blockchain networks. The surprising part? It all started with a 10 ETH deposit that never actually reached the vault. Here's what happened. 1️⃣ Deposit detected A user submitted 10 ETH to a THORChain vault. The transaction appeared in an Ethereum block, and THORChain recorded the deposit. 2️⃣ Ethereum block reorg Ethereum replaced the original block, removing the deposit from the canonical chain. But THORChain had already accounted for those funds. 3️⃣ Incorrect refund The swap failed its price-limit condition, triggering a refund. THORChain sent 10 ETH to the user, even though its vault had never received the corresponding deposit. 4️⃣ Emergency halt THORChain's solvency checker detected the shortfall and paused swaps. The user later returned the extra 10 ETH. So, what went wrong technically? The key issue was the difference between observing a transaction and having sufficient confirmation that it will remain in Ethereum's canonical history. A transaction appearing in a block doesn't mean that block cannot be reorganized. This is where @ethlabs_org raised an interesting solution: Ethereum's Fast Confirmation Rule (FCR). Instead of simply waiting for an arbitrary number of blocks, FCR analyzes Ethereum validator attestations to determine whether a block has sufficient support. It can provide strong confirmation in roughly 15–30 seconds, significantly earlier than Ethereum's full consensus finality. But FCR isn't absolute finality. Its guarantees still depend on network and validator assumptions. The important distinctions: • Transaction observed ≠ Transaction finalized • Block confirmations ≠ Validator-attestation-based confirmation • Fast confirmation ≠ Consensus finality For cross-chain infrastructure, receiving a deposit is only one part of the process. Verifying that the source-chain transaction is sufficiently secure before releasing funds is equally important. That's what makes this incident such a useful example of why confirmation and finality should not be confused.

Tokenized stocks are bringing traditional equities onchain. But there's a major bottleneck holding back their DeFi potential: fragmented liquidity. Today, the same stock can be tokenized by different issuers, deployed across multiple chains, and traded in isolated liquidity pools. Even though these tokens represent the same underlying asset, their liquidity isn't necessarily shared. This creates three fundamental problems: ⚠️ High price impact: Large swaps can face significant slippage when liquidity is scattered across shallow pools. ⚠️ Poor capital efficiency: Liquidity providers must spread capital across multiple venues instead of concentrating it. ⚠️ Limited DeFi composability: Using tokenized stocks across swaps, lending, collateral, and automated strategies remains unnecessarily complex. So what's missing? I believe two infrastructure capabilities are critical: ✅ Liquidity aggregation to connect fragmented liquidity and improve trade execution. ✅ Synchronous composability to enable swaps, lending, and collateral operations to interact atomically, without fragmented execution flows. And this matters even more as AI agents enter onchain finance. Imagine an AI agent swapping USDC into tokenized stocks, depositing them as collateral, borrowing against them, and redeploying all capital within a single atomic transaction. That's where tokenized assets become truly programmable financial building blocks. The next breakthrough in tokenized stocks won't just be 24/7 trading. It will be deep liquidity combined with seamless DeFi composability. This is why we are excited about @puffer_unifi. With Ethereum L1 liquidity access, synchronous L1–L2 composability, and low-latency execution, UniFi is building toward the infrastructure needed for more connected, capital-efficient onchain finance. Tokenization brings assets onchain. Liquidity and composability unlock what those assets can actually do.

Google is getting deeper into crypto infrastructure. It's introducing a Multi-Party Compute (MPC) security solution to help institutions securely custody and transfer digital assets. As more institutional capital moves onchain, security needs to go beyond smart contract audits. Key management, transaction authorization, and operational security are just as critical. MPC isn't new, but seeing Google invest in this space is another encouraging signal for institutional blockchain adoption. The next phase of crypto isn't just about faster and cheaper transactions. It's also about building infrastructure that institutions can trust. Congrats to the Google team on the great work! 👏 Exciting to see more major tech companies helping move the crypto forward.

The idea behind EIP-8450: Don't wait for quantum computers. Get the keys ready while BLS is still secure. Validators would register a quantum-resistant key in beacon state today. It stays dormant this fork, and a later fork switches duties over to it. 🔐 Hash-based leanXMSS key + a 32-byte vrf_root, ~2.6 KB per registration 📊 The registry shows how much stake is actually PQ-ready before any switch ⚠️ Open questions: who can authorize key changes, and DVT costs flagged by Obol (~55–164 GB key shares per node) For stakers and restaking operators, there's nothing to do yet, but every validator will eventually need a PQ key. Prepare early. Switch when it's safe.👇

BNB Chain is planning a new high-performance L1 dedicated to applications like high-frequency trading, onchain order books, and payments. Why build another chain alongside BSC? Because general-purpose blockchains aren’t optimized for every workload. As onchain finance evolves, applications increasingly demand dedicated execution capacity, lower latency, and more predictable performance than shared execution environments can consistently provide. We’re seeing a broader shift: from one chain serving every application to specialized chains built around specific needs. That’s also the direction we’re taking with @puffer_unifi, but with a different architectural approach. Instead of launching independent L1s, Puffer UniFi is building Ethereum-aligned based rollups that provide: ⚡ Dedicated execution optimized for different applications. 🔗 Ethereum settlement, leveraging Ethereum as the underlying settlement layer. 💧 Synchronous composability, designed to connect appchains directly with Ethereum’s liquidity and smart contracts. Specialized execution. Shared Ethereum liquidity. Ethereum settlement. Scaling shouldn’t mean building isolated ecosystems.

Interesting read on the future of agent-to-agent commerce. One takeaway that stood out to me: payments might be the easiest part of the agentic economy. We’re seeing a lot of infrastructure being built around AI agents making payments. But what happens when agents start negotiating, trading, and managing financial risks with each other? The article raises a few interesting points: 1. Payment ≠ Trust. Agents can transfer money instantly, but that doesn’t guarantee the other party will deliver. Escrow, collateral, and enforceable commitments become essential. 2. Agents will need to hedge risks. Think GPU prices, compute availability, or delivery deadlines. Most of these risks are too specific for traditional financial markets. 3. Markets could become disposable. An agent creates a market around a specific risk, other agents provide liquidity if they have a reason to, and the market disappears once the event is settled. The third point is particularly interesting. We might be moving toward a world where markets are created on demand, not just for assets people want to trade, but for uncertainties that individual agents need to manage. This also makes me think about what we’re building with @puffer_unifi. If agents are going to coordinate economic activity at machine speed, they’ll need more than payment rails. They’ll need high-performance execution, fast transaction assurances, and access to Ethereum’s liquidity and financial primitives. That’s where infrastructure like Puffer UniFi could play an important role. The next wave of agentic commerce may not be defined by how much money agents move, but by how much economic activity they can coordinate on their own.

🌊Synchronous Composability Is the Real Breakthrough (4) One of the most important technical insights from Amir's keynote at Agentic Settlement Night didn't get the loudest applause, but I think it matters most. Start with a simple scenario. An application on an L2 wants to use liquidity that lives in a DeFi protocol on Ethereum L1. Today, that usually means one of three things: 1. bridging assets across and waiting 2. asynchronous messaging, where the L2 sends a request and hopes the state hasn't changed by the time it lands 3. replicating liquidity on every chain, which splits it up and leaves each pool thinner Each option adds latency, risk, or cost. Over time, this is how Ethereum's scaling story turned into a fragmentation story. More rollups, more islands, and liquidity spread thinner across all of them. @puffer_unifi is designed to change that. With synchronous composability, L1 and L2 applications can interact within one coordinated transaction. The L2 can read from L1, act on it, and settle back, all at once and with no waiting step in between. The key line for me: liquidity doesn't need to move just because execution moves. Why this matters: - Builders can launch on an L2 for speed and cost without giving up access to Ethereum's deepest liquidity. - Users get one atomic experience: it all works or none of it happens. No half-finished cross-chain states. Institutions and AI agents get settlement they can reason about, because the whole flow either completes or reverts. - That's a fundamentally different approach to scaling Ethereum. Instead of building away from L1, you build with it. And this isn't just theoretical. On stage, our co-founder @AmirOnchain showed a flash loan taken on Ethereum L1, used for execution on Puffer UniFi's testnet, then repaid on L1, all within the same transaction. A flash loan only works if it's repaid in the same transaction. So running one across L1 and L2 is about the clearest proof there is that the two layers are actually composing in sync. For agentic commerce, this is the foundation. Agents need speed, but they also need payments that are right every time. Fast execution on Puffer UniFi, settlement on Ethereum, and no liquidity left stranded in between. Ethereum doesn't need more islands. It needs layers that work as one.

Ethereum upgrades since London: Past → present: Merge, Shapella withdrawals, Dencun blobs (L2 fees −90–98%), Pectra (EIP-7702 + bigger validators), Fusaka (native P-256/passkeys), gas ~60M. Next: Glamsterdam (~Dec 2026) Capacity fork. ePBS puts the builder auction in-protocol. Block access lists unlock parallel verify. Path to ~200M gas, but new storage gets expensive (ETH to a fresh address ~9.7× today). At 60M costs rise; at 200M most txs can get cheaper. Then: Hegotá (~2027) Frame txs = pick your own signature check + gas payer (USDT sponsorship, fund pays for investor). FOCIL = a validator committee can force waiting public txs into the next block. 10s slots under consideration. Still not on these forks: confidentiality from the RPC/builder. Finality in seconds + post-quantum crypto ≈ end of decade. Full institutional cheatsheet from EthSystems:

🌊 Why Does Ethereum Need Puffer UniFi? (2) Ethereum doesn’t have a shortage of liquidity. It has a problem making that liquidity accessible across an increasingly fragmented ecosystem. Think about it. Ethereum has become the home of onchain finance, with billions of dollars in stablecoins, DeFi liquidity, and tokenized assets. But as Ethereum scales through rollups, something interesting happens. Every new rollup brings more execution capacity, lower costs, and better performance. The trade-offs? Liquidity fragmentation and sequencer centralization. 1️⃣ Fragmented Liquidity Assets and applications are spread across different execution environments, each with its own state and liquidity pools. Moving value between them often requires bridges, asynchronous messaging, or liquidity providers maintaining capital across multiple chains. We’re scaling execution, but making Ethereum’s liquidity harder to use as one connected financial system. 2️⃣ Centralized Sequencing Many rollups rely on centralized sequencers to order transactions. While this allows for fast execution, it also introduces additional trust assumptions and potential risks around censorship, transaction ordering, and sequencer availability. Even when transaction validity and settlement are secured by Ethereum, sequencing can remain dependent on a single operator. So here’s the question: Can we scale Ethereum without sacrificing composability and decentralization? That’s what we’re working toward with @puffer_unifi. Puffer UniFi is building an Ethereum-aligned Based Rollup infrastructure stack designed to address both challenges. ⚡ Dedicated execution: Applications can have their own high-performance execution environments tailored to their needs. 🔗 Synchronous composability: Rollups built on the Puffer UniFi stack are designed to interact with Ethereum L1 liquidity and smart contracts through coordinated, atomic transactions. 🔐 Ethereum-aligned sequencing: Based sequencing is designed to bring transaction ordering into alignment with Ethereum’s validator infrastructure, reducing reliance on independent centralized sequencers. Imagine a DeFi application running on a dedicated rollup while accessing liquidity from Aave or Uniswap on Ethereum L1, without bridging assets into a separate liquidity pool. And this isn’t just a concept. At our recent Agentic Settlement Night in Singapore, our co-founder @AmirOnchain demonstrated synchronous L1–L2 composability on testnet: borrowing from Aave on Ethereum Sepolia, executing transactions on Puffer UniFi, and repaying the flash loan on L1 - all within a single atomic transaction. That’s a glimpse of what synchronous composability can unlock. The bigger opportunity is making Ethereum’s existing liquidity more accessible and composable, while building toward more decentralized execution infrastructure.