Ethereum Fusaka: Infra upgrade for real scaling

What’s new in the Ethereum Fusaka upgrade

Ethereum is securely scaling with Fusaka, which brings a powerful upgrade, giving the entire ecosystem a major boost. It unlocks more space for rollups, introduces cleaner rules for infrastructure, improves data handling, and provides better tools for developers. Most of the action happens under the hood, but the ripple effects will be felt across the network as L2s and apps upgrade while the ecosystem begins taking advantage of Fusaka’s improvements.

Ethereum’s Fusaka upgrade brings a hybrid, secure, and scalable approach to L1 and L2 enhancements, improving throughput, reliability, and developer experience without compromising decentralization.

Before diving into the details, here’s what you should be familiar with.

Prerequisites

• Basic understanding of Ethereum L1 and L2 architecture.
• Familiarity with Ethereum upgrades and EIPs.

Key Features for Rollups, Infra & Builders

PeerDAS & Blob Capacity Boost

PeerDAS unlocks up to 8× more data availability, giving rollups far more room for posting data while keeping nodes lightweight. Fusaka increases the capacity for blobs per block, from 6 blobs/block after Dencun to 15 blobs/block with BPO-1 (activated) and further increases coming in January.

Passkey & Hardware-Secure Signatures

EIP-7951 introduces secp256r1 support, enabling device-native signing and passkeys. Wallets can use hardware security modules (HSMs) and FIDO2/WebAuthn directly, allowing smoother onboarding, easier recovery, and multi-factor flows that feel like modern apps on phones and laptops, with no seed phrases required.

Cleaner, More Stable Infra Unified execution rules, predictable RLP block sizes, deterministic proposer scheduling, and eth_config auto-discovery simplifies operations for RPCs, sequencers, explorers, and client teams. Nodes become lighter, more reliable, and easier to scale, setting the foundation for smoother L2 growth and better developer experience.

For Regular Web3 Users

The impact unfolds gradually as L2s and wallet providers adopt the new capabilities. Over time, users will notice faster transactions, lower L2 fees, and more responsive apps. Mobile wallets will start supporting passkeys, fingerprints, and Face ID for secure, seamless logins without seed phrases, making onboarding and account recovery simpler than ever. The result is a smoother, more predictable Ethereum experience that feels closer to the ease and speed of modern consumer apps.

Nothing changes in how people use Ethereum, but the network around them becomes more efficient and predictable. Over time, everyday activity feels faster, cheaper, and more stable.

What is EIP-7607: Hardfork Meta – Fusaka

EIP-7607, the Fusaka hardfork meta, is one of the most significant upgrades, bundling 13 EIPs into a hybrid upgrade for Ethereum. Fusaka improves data availability, increases blob capacity, stabilizes fees, and upgrades L1 execution limits, making Ethereum faster, cheaper, and more predictable for both everyday users and builders.

• Consensus Layer (“Fulu”, the star): Enhances L2 interoperability, allowing rollups to post data efficiently.
• Execution Layer (“Osaka”, a city in Japan): Simplifies developer deployment and node operation with better tooling and gas management.

The upgrade has been activated on testnets such as Holešky, Sepolia, Hoodi, and mainnet, ensuring widespread client support and robust testing across environments. Validators, L2 operators, developers, and users will all feel the effects, lower fees, faster finality, and more reliable network behaviour, making Fusaka one of the most consequential upgrades in Ethereum’s history.

Fusaka delivers changes across data availability, user experience, and L1 performance. Each area plays a role in making Ethereum faster and more reliable. The following sections explore each of these areas and what they unlock for the ecosystem.

Data Availability

EIP-7594: PeerDAS – Peer Data Availability Sampling

PeerDAS (Peer Data Availability Sampling) is a core EIP that enables Ethereum nodes to perform DAS by downloading only a subset of data. Before Fusaka, each node downloaded the full blob to verify availability. This limited Ethereum’s blob throughput, often causing high blob fees for rollups during periods of congestion.

PeerDAS introduces a major improvement by splitting blob data into columns (hence, the zebra mascot, representing the striped column-based data availability sampling) and distributing them uniformly across the network. Each node downloads only 1/8th of the blob data at random. Since no single node ever needs to download the full blob, running a node becomes significantly lighter and more accessible.

EIP-7892: Blob Parameter Only Hardforks

BPO (Blob Only Parameters) hardforks allow incremental, safe scaling of Ethereum’s data availability (DA) layer. All L2s depend on the DA layer, and as these networks expand, they require more data availability. To accommodate this growing demand, Ethereum increases the number of blobs per block, providing continuous and predictable scaling for the L2 ecosystem built on top of Ethereum.

BPO hardforks provide continuous scaling with a gradual increase in the number of blocks per block by modifying only blob-related parameters: target, max and baseFeeUpdateFraction through config, without requiring any client-side changes.

Blobs were introduced in the Dencun upgrade with a target of 3 blobs per block. The Pectra upgrade subsequently doubled this capacity to 6 blobs per block, and with Fusaka, Ethereum now supports gradual, controlled increases in blob capacity, allowing the network to scale securely and predictably in line with L2 demand.

With the recent activation of BPO-1, blob capacity has already increased to 15 blobs per block.

BPO-2 is scheduled to be activated in January.

EIP-7918: Blob base fee bounded by execution cost

EIP-7918 pins a proportional reserve price BLOB_BASE_COST * base_fee_per_gas to blobs by introducing an if-clause in calc_excess_blob_gas() under every blob. When this reserve price exceeds GAS_PER_BLOB * base_fee_per_blob_gas, the function stops subtracting target_blob_gas and lets excess_blob_gas increase strictly according to blob_gas_used, while keeping the per-block maximum increase unchanged.

The result is a more stable, predictable blob pricing mechanism that continues to function even as L2 throughput increases with PeerDAS and BPO upgrades.

In summary,

• PeerDAS (7594): reduces node load, improves sampling efficiency
• BPO (7892): allows incremental blob scaling
• Blob Base Fee Bound (7918): ensures predictable costs

Impacts:

• Node operators: Reduced load and faster synchronization due to PeerDAS sampling.
• L2 networks & rollups: Greater, predictable blob capacity enables higher throughput and reliable data posting on Ethereum.
• Users & dApps: More stable and lower L2 fees with faster transaction finality.

Together, these upgrades allow Ethereum to scale securely, unlocking up to ~8× more DA capacity without compromising decentralization or security.

UX Improvements

EIP-7951: Precompile for secp256r1 Curve Support

EIP-7951 adds on-chain support for the secp256r1 (NIST P-256) elliptic curve, widely used in WebAuthn, FIDO2 devices, and enterprise security systems. Until now, Ethereum only handled secp256k1 and BLS12-381, meaning developers had to rely on off-chain verification or expensive custom contracts to work with P-256 signatures. This precompile brings fast, low-gas verification directly into the EVM.

This EIP introduced a functionality to efficiently perform ECDSA signature verification over the secp256r1 elliptic curve (also known as P-256 or prime256v1) at the fixed address 0x100. This precompile enables native support for signatures generated by modern secure hardware including Apple Secure Enclave, Android Keystore, and FIDO2/WebAuthn devices.

This unlocks the usage of secure hardware devices, non custodial wallets and applications can natively verify signatures from secure hardware like smartphones, fingerprint/Face ID sensors, and hardware security modules. Users can interact with Ethereum dApps using familiar, secure authentication methods without depending on third-party relays or custodial solutions.

This EIP essentially bridges modern authentication standards with Ethereum smart contracts, making non-custodial wallets more user-friendly and enterprise adoption smoother, all while preserving strong cryptographic security

Impacts:

• App & DeFi developers: Can integrate WebAuthn/FIDO2 authentication natively in contracts.
• Wallets: Enable smoother onboarding and secure hardware-based authentication.
• Enterprise: Leverage industry-standard cryptography for blockchain solutions.
• Users: Secure, seamless, self-custodied access using modern authentication devices.

EIP-7910: eth_config JSON-RPC Method

A Meta EIP introduces a unified eth_config RPC call that lets applications query a node’s current configuration: chain ID, fork rules, EVM revision, blob parameters, and more, all from one endpoint.

Instead of hardcoding chain assumptions, developers can fetch them dynamically, reducing mismatches and configuration errors across L1, L2s, and testnets.

Impacts:

• App & DeFi developers: Expect fewer config mismatches across mainnet, L2s, and testnets. Use eth_config at app startup to automatically configure chain rules.
• Rollups & L2 infra teams: Can dynamically adjust sequencers, verifiers, and gas models without redeploying contracts or manually editing config files.
• Explorers & Tooling: Improved multi-chain support with consistent metadata pulled from the node itself.

EIP-7939: Count leading zeros (CLZ) opcode

EIP-7939 adds a new built-in EVM opcode called CLZ, which returns how many zeros appear at the front of a 256-bit value. This is a very common low-level operation used in cryptography, Merkle tries, hashing, and many math operations but until now, developers had to simulate it manually with loops or binary-search logic, which costs a lot of gas.

By introducing CLZ as a single native opcode, the EVM can compute this result instantly and cheaply. This makes many protocol-level operations faster, more predictable, and less gas-heavy, especially for L2s and zk systems that depend on precise bit manipulation.

Solidity and other EVM compilers will add direct support for CLZ in upcoming releases. Once they do, contracts that depend on leading-zero calculations can become cheaper automatically at compile time. Developers simply need to update to newer compiler versions and review release notes to understand where gas reductions apply.

EIP-7917: Deterministic Proposer Lookahead

EIP-7917 gives the beacon chain a fully deterministic view of next-epoch block proposers. Instead of relying on balances that may change mid-epoch, the proposer list is precomputed and stored directly in the beacon state. This eliminates unpredictable edge cases where validator balances could alter the proposer schedule.

With the next epoch’s proposers known in advance, preconfirmation protocols, builders, validators, and relays gain stable coordination, predictable rotations and fewer last-minute proposer surprises.

Scaling L1

EIP-7823: Set upper bounds for MODEXP & EIP-7883: ModExp Gas Cost Increase

EIP-7823 introduces hard upper bounds on input sizes for MODEXP, preventing transactions from submitting extremely large parameters that could lead to long execution paths or unpredictable resource usage. This ensures that even in complex cryptographic workloads, MODEXP remains bounded, auditable, and safe for clients to process.

EIP-7883 adjusts the gas schedule for MODEXP to better reflect its true computational cost. By increasing gas for expensive parameter ranges, the EVM aligns pricing with real-world execution effort, discouraging pathological input patterns and reducing DoS vectors. Together, these changes make MODEXP more predictable for node operators, safer for block builders, and more reliable for applications that rely on modular exponentiation, especially rollups, verification systems, and protocols performing heavy cryptographic operations.

Contracts that depend on EIP 7883 will consume more gas for execution. If your contract relies heavily on this and becomes more expensive for users, reconsider how it’s utilized.

EIP-7825: Transaction Gas Limit Cap & EIP-7935: Set default gas limit to 60M

EIP-7935 proposes raising Ethereum’s default block gas limit toward ~60M, increasing total execution capacity per block and enabling higher throughput during Fusaka. Larger blocks, however, naturally increase the amount of work nodes must verify, which makes the behaviour of individual high-gas transactions more important for network stability. EIP-7825 sets a strict per-transaction cap of 16,777,216 gas, ensuring no single transaction consumes disproportionate resources as block limits rise.

Together, they can create a controlled path for execution-layer scaling: more room for transactions overall, but bounded per-transaction complexity to preserve stability, fairness, and predictable validation across clients. The network gains higher throughput without exposing itself to single-transaction DoS risks or extreme state-growth spikes, making Fusaka’s higher gas-limit regime feasible and safe.

EIP-7934: RLP Execution Block Size Limit

EIP-7934 introduces a protocol-level cap on the RLP-encoded execution-block size, aligning the execution layer with the consensus layer’s gossip constraints. Clients define:

• MAX_BLOCK_SIZE = 10,485,760 bytes (10 MiB)
• SAFETY_MARGIN = 2,097,152 bytes (2 MiB reserved for beacon-block framing)
• MAX_RLP_BLOCK_SIZE = MAX_BLOCK_SIZE − SAFETY_MARGIN

Any execution block whose RLP payload exceeds MAX_RLP_BLOCK_SIZE is rejected. This is a byte-level propagation limit, not a gas-accounting change. It constrains the maximum amount of encoded block data transmitted across the network, preventing execution blocks from exceeding the CL gossip threshold (~10 MiB) and eliminating scenarios where a block is valid for execution but too large for consensus propagation.

EIP-7642: eth/69 – history expiry and simpler receipts

EIP-7642 cleans up the Ethereum networking protocol by dropping handshake fields that became obsolete after the Merge. These fields were carried forward for compatibility but provided no functional value, increasing complexity in peer discovery and node communication.

By removing them, clients ship with a leaner networking layer: fewer conditional checks, lower handshake overhead, and a reduced attack surface. This is especially impactful for embedded devices, light clients, and high-volume infrastructure nodes where efficiency compounds quickly.

Conclusion

Fusaka demonstrates Ethereum’s evolution as a secure, scalable, and developer-friendly blockchain. By combining L1 and L2 upgrades, optimized data availability, enhanced gas management, and developer-centric tooling, Ethereum now supports higher throughput without compromising decentralization.

Looking ahead, Fusaka lays the foundation for:

• Further incremental scaling via Blob Parameter Only hardforks.
• Improved UX with hardware wallet integration and modern authentication.
• Predictable transaction costs and safer network operation.

Running your own Ethereum node is essential for reliable access to the upgraded network. Chainstack makes this simple, you can deploy fully managed Ethereum nodes in minutes, ensuring access to the latest features, RPC methods, and network data.

Ethereum continues to grow as a platform for secure, permissionless innovation, maintaining a balance between decentralization, usability, and high-performance L2 interoperability.

Ethereum is scaling securely.

Reliable Ethereum RPC infrastructure

Getting started with Ethereum on Chainstack is fast and straightforward. Developers can deploy a reliable Ethereum node within seconds through an intuitive Console — no complex setup or hardware management required. 

Chainstack provides low-latency Ethereum RPC access, ensuring seamless connectivity for building, testing, and scaling DeFi, analytics, and trading applications. With Ethereum low-latency endpoints powered by global infrastructure, you can achieve lightning-fast response times and consistent performance across regions. 

Start for free, connect your app to a reliable Ethereum RPC endpoint, and experience how easy it is to build and scale on Ethereum with Chainstack – one of the best RPC providers.