EIP-4844 (Proto-Danksharding) and Rabby Wallet: How Blob Transactions Will Change Gas Fee Prediction

Ethereum’s EIP-4844, activated in March 2024, introduced a separate pricing mechanism for blob data that exists outside the main transaction execution layer. This proto-danksharding upgrade fundamentally altered how gas fees work on Ethereum and all EVM-compatible chains that adopt it. A user attempting to estimate costs for a swap, mint, or bridge transaction now encounters a dual pricing model: one fee for computation and storage on the main chain, another for temporary blob storage. Wallet software that does not account for this split will either misprice transactions or fail to explain why quoted fees differ from actual costs.

Rabby Wallet, as a non-custodial Ethereum wallet supporting multiple EVM chains, faces a direct product challenge. Its transaction preview and fee estimation engine must distinguish between traditional calldata and blob data, display each separately, and adapt to the volatile blob pricing that responds to network demand in near-real time. Users who understand the change can make better decisions about timing and route selection; those who do not may blame the wallet for unexpected costs or assume that a quoted fee is incomplete. This article examines how EIP-4844 works technically, why existing wallet UX breaks under blob pricing, and how Rabby and similar wallets must evolve to remain accurate as Ethereum’s fee structure continues to fragment.

What EIP-4844 actually changed in Ethereum’s fee model

Before EIP-4844, Ethereum had one gas market. Every byte of data in a transaction cost 16 gas if it was non-zero or 4 gas if zero, and the base fee per gas unit fluctuated based on block fullness. Layer 2 solutions like Arbitrum and Polygon compressed transactions into batches and posted the batch data to Ethereum as calldata. That calldata competed with regular transactions for block space, and in times of high Layer 2 activity, calldata fees could dominate the total cost. A rollup batch with 100 kb of compressed data might pay millions of dollars in Ethereum base fees just to record that data.

EIP-4844 created a separate market: the blob market. A “blob” is a 4,096 byte piece of data that is attached to a block but is not stored permanently in the execution layer. Ethereum nodes keep blobs for about 18 days, which is enough for rollup nodes to download and validate them, but not long enough to burden nodes indefinitely. The blob fee starts at 1 wei per gas equivalent and adjusts every block based on how many blobs were used in the previous block. If blocks are empty of blobs, the fee drops exponentially. If blocks are full of blobs, the fee increases exponentially. This mechanism decouples blob storage pricing from computation pricing and allows Layer 2 solutions to access much cheaper temporary storage.

The practical effect is that rollup transactions can be posted to Ethereum at a fraction of their previous cost. An Arbitrum transaction that previously cost users 100 dollars in Ethereum fees might now cost 2 dollars. But from a wallet’s perspective, the fee estimation problem became more complex. A transaction sent directly on Ethereum still uses the base fee and priority fee for execution. A Layer 2 batch posted to Ethereum now has a base fee, priority fee, and blob fee that are calculated independently and fluctuate on different schedules. A wallet that quotes only the base fee plus priority fee will underestimate Layer 2 posting costs. A wallet that quotes the blob fee without the base fee will confuse users about the total cost.

The separation also creates an asymmetry in fee volatility. Base fees and priority fees respond to transaction demand; blob fees respond to Layer 2 batch posting demand. These are correlated but not identical. During a NFT mint on Ethereum mainnet, base fees spike but blob fees remain low because no Layer 2 activity is happening. During a period of high Layer 2 volume, blob fees can spike while mainnet base fees are moderate. A wallet that treats all fees as a single number will produce incorrect predictions during these mismatched conditions.

Why traditional wallet fee estimation fails under dual pricing

Rabby Wallet, like other EVM wallets, historically estimated fees by querying the Ethereum network for the current base fee and priority fee, applying a buffer, and multiplying by the estimated gas limit. This approach works well when every transaction uses the same pricing mechanism. It breaks when transactions can contain blobs that use a separate pricing model. A user sending a transaction on Arbitrum that will be posted as a blob to Ethereum cannot know the final cost until Rabby queries the blob fee separately and incorporates it into the quote.

The first failure mode is incomplete quotes. If a wallet fetches the base and priority fee but not the blob fee, it will show a cost that is too low. Users see the quote, approve it, and discover post-broadcast that the actual fee was higher. This erodes trust and creates support burden. Users may blame the wallet rather than understanding that they were looking at incomplete information. The second failure mode is temporal misalignment. A blob fee fetched now may not be the blob fee when the transaction is actually included in a block. If the user delays even 10 seconds, the blob fee can move significantly. A wallet that does not update the quote in real time or warn the user about fee expiration will produce stale information.

The third failure mode is the “which chain?” problem. Rabby supports Ethereum, Arbitrum, Polygon, Avalanche, Fantom, and many other EVM chains. Not all of them have adopted EIP-4844 or use blobs in the same way. Arbitrum has its own sequencer fee separate from the base fee. Polygon does not currently use blobs. A wallet must know, for each chain, whether the transaction uses blob pricing and handle it appropriately. Collapsing all chains into one fee estimation logic will produce wrong answers for at least some of them.

The fourth failure mode is display ambiguity. If a wallet shows a single “gas fee” amount, users cannot tell whether that number includes blob costs or not. If it shows “base fee + priority fee + blob fee” separately, users may misunderstand what each component means or when each one applies. If it tries to combine them into a single “estimated total,” that number will be precise only at the moment it was generated. A wallet cannot solve this problem with better math; it requires better communication. Rabby and similar wallets must make it clear to users that they are looking at a prediction, why the prediction could be wrong, and what will happen if they approve the transaction.

How Rabby’s fee estimation engine must adapt

A robust fee estimation strategy for an Ethereum wallet or EVM wallet operating across multiple chains must include several layers. The first layer is chain detection. When a user initiates a transaction, the wallet must identify the destination chain and determine which pricing model applies. For Ethereum mainnet, is it a direct transaction or a Layer 2 batch? For Arbitrum, does it incur a sequencer fee? For Polygon, what fee structure is currently active? This information must be maintained as each chain’s protocol evolves, which means regular updates distributed through the download channel to ensure users have accurate data.

The second layer is real-time data fetching. Instead of a single RPC call that returns one base fee and priority fee, the wallet must query separate endpoints for base fee, priority fee, and blob fee where relevant. These queries must happen close together in time to minimize inconsistency, but they cannot happen simultaneously because network delay will cause them to reflect different block states. Rabby must decide whether to fetch the most recent state from all three sources, even if they are slightly out of sync, or to use a stale consistent state where all three come from the same block. The former approach produces more current estimates; the latter produces more self-consistent estimates. Most wallets choose recent over consistent because users care more about not being surprised than about internal coherence.

The third layer is confidence bounds. A wallet should display not just a single “estimated fee” but also a range and a confidence level. If the wallet estimates a blob fee based on the last block’s rate, and the rate can double in the next block, the quote is only valid for seconds. A wallet that shows the range (e.g., “0.1 ETH to 0.15 ETH”) and the time window (“valid for 30 seconds”) gives users information to make a decision. Rabby’s transaction preview feature can incorporate this by showing the fee estimate with a timestamp, an expiration time, and a “refresh” button that the user can click to update the quote. Without this feature, users must choose between stale information and constantly refreshing the page.

The fourth layer is explanatory clarity. When a wallet shows a fee, it should explain what is included. “Network fee” or “gas fee” are now ambiguous terms. Rabby should display “Execution fee (base + priority): X” and “Blob storage fee: Y” separately, with brief tooltips explaining what each one is. A user who understands that the blob fee is temporary storage for Layer 2 data will be less surprised when that fee changes between chains or drops when Layer 2 activity decreases. A user who thinks it is all one indivisible “gas fee” will be confused by any volatility or any split in the breakdown.

Fee prediction accuracy across EVM chains

Rabby’s multi-chain support means it must handle fee models that diverge significantly from chain to chain. Ethereum mainnet uses the base fee plus blob fee mechanism. Arbitrum One, which settles to Ethereum, charges users a base fee for execution on the Arbitrum sequencer, plus a separate fee for posting data to Ethereum. This poster fee is calculated as the cost of the Arbitrum batch divided among all users in that batch, which means an individual user’s poster fee depends on transaction ordering and timing. Arbitrum Nitro introduced a “deterministic” mode where the poster fee is more predictable, but it is still separate from the execution fee.

Polygon uses a traditional base fee model without blobs, at least for now. Avalanche C-Chain does not use EIP-4844. Fantom does not either. Each chain has its own base fee calculation, its own block time, and its own congestion dynamics. A wallet that assumes all EVM chains have the same fee structure will produce systematically wrong estimates. Rabby avoids this by maintaining chain-specific fee estimation logic, but keeping that logic up to date requires monitoring each chain’s protocol changes and updating the wallet accordingly. When a new chain adopts blob pricing or changes its fee mechanism, Rabby must be updated to handle the new model.

The practical implication for users is that a “secure crypto wallet” that operates across many chains must do significant engineering work behind the scenes. The user interface can look simple: click send, see the fee, approve. But the correct fee depends on accurate data about multiple independent fee markets. A wallet that shortcuts this work by using generic formulas or stale data will fail its users at the worst time, when network conditions are volatile or when that user cannot afford to pay an unexpected cost.

The special case of Layer 2 to Layer 2 interactions

EIP-4844 created a new routing problem. A user holding funds on Arbitrum who wants to move them to Optimism has multiple paths. They can bridge through a standard canonical bridge, which posts data to Ethereum as a blob and settles at the Ethereum layer. They can use a third-party bridge or liquidity provider that moves the funds off-chain. Or they can move to Ethereum mainnet first, then to Optimism. Each path has different fees, different settlement times, and different privacy properties. A sophisticated EVM wallet like Rabby can estimate the costs of each path and present them to the user, but only if the wallet has fee estimation logic for each path.

The blob fee complicates this further. A blob-based bridge may have a total cost that includes the Ethereum base fee, priority fee, and blob fee. A liquidity provider bridge may have fixed costs plus a spread. An off-chain bridge may have no on-chain fees but custodial risk. A wallet that quotes all three paths and labels them clearly with fee breakdowns helps the user make an informed choice. A wallet that shows only the headline “total fee” or, worse, shows different fee models for different paths without explanation, confuses the user about what they are paying for.

Hardware wallet compatibility matters here too. Rabby supports Ledger and Trezor hardware wallets, which means the signing device displays the transaction details before the user approves it. A hardware wallet with a small screen cannot display a detailed fee breakdown. It can show a total amount and the destination address, but explaining that “this includes a blob fee of 0.05 ETH because the bridge will post data to Ethereum” is beyond the typical hardware wallet’s UI. A companion software wallet like Rabby must provide clear information before the transaction is sent to the hardware device, so the user knows what they are signing.

Fee estimation in volatile and stable markets

EIP-4844’s blob fee mechanism has a built-in stability property: fees rise and fall exponentially as demand changes. During low demand, blob fees can fall to near-zero. During high demand from Layer 2 activity, they can spike significantly. This volatility creates a prediction problem that is fundamentally harder than base fee prediction. The base fee changes by at most 1.125 times per block (a built-in constraint that prevents runaway inflation). The blob fee can theoretically change by a factor of e ≈ 2.718 per block if conditions are extreme, which is much steeper.

A wallet trying to predict fees must therefore be more conservative with blob fee estimates. If the wallet observes a blob fee of 10 gwei and predicts the next block will have a 20 gwei blob fee, the user may approve at 20 gwei and discover the actual fee was 50 gwei. The safer approach is to add a larger buffer to blob fee estimates. Rabby could display “current blob fee: 10 gwei, estimated blob fee when included: 20 gwei” and recommend approving at 30 gwei to ensure inclusion. This communicates uncertainty to the user rather than pretending the prediction is accurate.

A related challenge is that blob fees and base fees move on different schedules. If the wallet fetches the base fee at time T1 and the blob fee at time T2, the two values come from different block states. An accurate estimate would re-fetch both from the same block, but that requires synchronizing the queries or fetching from an archive node that guarantees consistency. Most wallets accept the temporal inconsistency because the impact is small; but during high volatility, it could matter. Rabby’s implementation should acknowledge this trade-off explicitly: either fetch fresh data from potentially different blocks (low latency, possible inconsistency) or fetch consistent data from a known block height (higher latency, consistency).

User experience design for transparent fee breakdown

A secure crypto wallet succeeds not just by being technically correct but by communicating the technical reality to non-technical users. Rabby’s transaction preview feature is critical here. When a user initiates a transaction, Rabby shows the destination, amount, and fee breakdown. Under EIP-4844, this breakdown must include separate lines for execution fee (base plus priority) and blob fee where applicable. Each line should be labeled clearly and include a brief, non-technical explanation.

One effective pattern is to group related fees. For example: “Network fee: 0.05 ETH (includes base fee, priority fee, and blob storage)” with a small info icon that expands to “Base fee pays for transaction processing. Priority fee pays miners to include your transaction faster. Blob storage is a temporary fee for Layer 2 data that will be automatically cleaned up by the network.” This educates users without requiring them to understand every detail. A user who reads this will have a better mental model of what the fee is paying for than a user who sees only a single “gas fee” amount.

For power users, Rabby should provide advanced options. A user can select “high,” “standard,” or “low” fee tiers, and Rabby calculates the appropriate base fee, priority fee, and blob fee for each tier. The user can also manually set each fee component and see a real-time estimate of how long the transaction will take to confirm. This gives experienced users (many of whom manage their own portfolios or conduct DeFi trades) the control they need, while keeping the interface simple for casual users who just want to approve and move on.

NFT storage and management in Rabby also benefits from transparent fees. When a user mints an NFT or lists it for sale, the transaction fees are part of the total cost. A clear breakdown shows what the user is actually paying to interact with the smart contract versus what they are paying just to record the transaction on the blockchain. This helps prevent situations where a user mints a 0.1 ETH NFT and pays 0.05 ETH in fees, only discovering after the fact that they should have waited for lower base fees.

The long-term roadmap: Danksharding and beyond

EIP-4844 is called “proto-danksharding” because it is the first step toward full danksharding, which will increase blob capacity dramatically and split the role of proposers and builders. The full danksharding roadmap also includes changes to fee burn mechanisms, validator economics, and how the protocol prioritizes transactions. Each of these changes will again require wallet updates. A wallet that hard-codes fee estimation logic for today’s EIP-4844 structure will need to be redesigned when full danksharding arrives.

The sustainable approach is for wallets to treat fee estimation as a service query rather than hard-coded logic. Instead of Rabby calculating fees directly, it could query a fee estimation service that is maintained separately and updated more frequently. Services like Blocknative or similar providers already handle base fee prediction; the ecosystem will likely develop specialized blob fee estimators as well. A wallet can delegate to these services and display the results, confident that the estimates stay accurate as the protocol evolves.

This architecture also supports the portfolio dashboard feature in Rabby. When displaying the total value of a user’s holdings, the wallet can show estimated transaction costs for common operations (swap, send, stake, farm) based on current fee conditions. As the fee conditions change, these estimates update automatically. A user checking their portfolio can see not just what their assets are worth, but what it will cost to move or use them. This information supports better decision-making about when to execute trades or transfers.

Biometric security and hardware wallet integration will remain important as the wallet matures. The private key security model does not change with EIP-4844; users still need strong encryption and device protection. But as transactions become more complex (with separate fee components to understand and approve), the confirmation process becomes more important. A user who biometrically authenticates a transaction without reading the fee breakdown has not gained much security. Rabby should continue to emphasize that authentication confirms the user understands what they are signing, not just that the device recognizes them.