Introducing Jumbo Ethereum Transactions: Driving EVM-Compatibility on Hedera

By: Oliver Thorn

HIP-1086 introduces Jumbo Ethereum transactions, expanding callData limits from 6KB to 128KB for enhanced EVM compatibility. This milestone eliminates complex multi-step deployments, enabling developers to deploy large smart contracts in single transactions while maintaining Hedera’s predictable fees and superior performance advantages.

Enhancing EVM Compatibility on Hedera

At Hedera, we are continually committed to eliminating friction for developers migrating from other networks by driving EVM-compatibility — easing the transition for developers experienced with EVM-based networks looking to explore Hedera and leverage our network’s unique advantages of real-time settlement, fair transaction ordering, resistance to MEV attacks, and low, predictable fees.

HIP-1086 — Jumbo EthereumTransaction — represents a significant milestone in our ongoing mission to make development on Hedera as seamless as possible. By increasing callData limits for EVM-based transactions, HIP-1086 expands the possibilities for complex smart contract deployments and large-scale data operations while bringing the developer experience more in line with other EVM networks.

Rather than simply addressing constraints, this enhancement opens new frontiers for developers building sophisticated DeFi protocols, oracle networks, and enterprise applications that require substantial callData capacity within single transactions. Let’s dive in and see what this means for users, developers, and the ecosystem as a whole.

Breaking Down the Breakthrough: What HIP-1086 Delivers

HIP-1086 introduces configurable transaction size limits for EthereumTransactions, expanding callData capacity from the network’s standard 6KB limit up to 128KB. This change brings Hedera’s transaction capabilities in line with other major EVM networks, where developers routinely work with larger smart contracts and substantial data payloads.

This enhancement specifically targets EthereumTransactions while maintaining the existing transaction model for other Hedera operations.

Transaction costs are calculated using familiar EVM gas mechanics — 4 gas per zero byte and 16 gas per non-zero byte — ensuring developers can accurately estimate costs while benefiting from Hedera’s characteristically low fees.

To maintain network stability and fair access, HIP-1086 introduces a dedicated throttling system for jumbo transactions. This network-wide bytes-per-second throttle ensures that larger transactions don’t impact overall network performance while giving all participants equitable access to enhanced transaction capabilities — delivering powerful new features while preserving the network’s reliability and fairness principles.

Simplified Workflows and Enhanced Possibilities

The most immediate impact of jumbo transactions is the elimination of complex multi-step deployment processes. Previously, developers working with large smart contracts needed to upload contract bytecode to the Hiero File Service through multiple FileCreate and FileAppend transactions before referencing that file in their EthereumTransaction.

Now, developers can deploy substantial smart contracts in a single transaction, matching the streamlined experience they’re accustomed to on other EVM networks.

This improvement particularly benefits developers building data-intensive applications like oracle networks that need to submit large datasets, complex DeFi protocols with extensive initialization parameters, or NFT collections requiring substantial metadata. Oracles can now deliver comprehensive price feeds and market data in single transactions, while DeFi protocols can initialize with complete configuration sets without fragmented deployments.

Throughout this enhancement, developers maintain full compatibility with their existing EVM toolkit. Whether using Hardhat for development, Ethers.js for interaction, or Remix for quick prototyping, the workflow remains unchanged. These tools now unlock the full potential of complex applications without the overhead of file management, further bringing Hedera to the forefront of enterprise-grade, interoperable Web3 development.

Powering the Ecosystem: Benefits for Relay Operators and the Broader Network

JSON-RPC relay operators — who provide a crucial bridge between EVM tooling and the Hedera network — gain significant operational advantages from jumbo transactions.

Previously, relay operators faced complex business model challenges when handling large contract deployments, as they needed to manage the costs and complexity of multiple HFS transactions on behalf of users. With single-transaction deployments now possible, relay operators can offer more streamlined services while maintaining predictable cost structures for their users.

The network-wide throttling system ensures that these enhanced capabilities don’t compromise Hedera’s stability and fairness. By implementing a bytes-per-second throttle distributed across all network nodes, HIP-1086 maintains equitable access to jumbo transaction capacity while preventing any single participant from overwhelming the network.

These improvements strengthen the entire Hedera ecosystem by making it easier for cross-chain infrastructure providers to offer competitive services. As relay operators can now handle complex transactions more efficiently, the barrier to entry for sophisticated dApps decreases, attracting more developers and projects to build on Hedera. The result is a more robust, accessible network that maintains its performance advantages while expanding its appeal to the broader EVM developer community.

Code Snippets

Let’s examine how the implementation of HIP-1086 enables developers to streamline the deployment of large smart contracts through more efficient use of code:

Before HIP-1086:

// --- 1. read compiled bytecode ---------------
const bytecode = fs.readFileSync(BYTECODE_PATH);

// --- 2. create on-chain file & first chunk ---
const createRx = await(
    await new FileCreateTransaction()
        .setKeys([PrivateKey.fromStringECDSA(process.env.OPERATOR_KEY).publicKey])
        .setContents(bytecode.slice(0, CHUNK_SIZE))
        .setMaxTransactionFee(new Hbar(2))
        .execute(client)
).getReceipt(client);

const fileId = createRx.fileId;

// --- 3. append remaining chunks --------------
for (let i = CHUNK_SIZE; i < bytecode.length; i += CHUNK_SIZE) {
    await(
        await new FileAppendTransaction()
            .setFileId(fileId)
            .setContents(bytecode.slice(i, i + CHUNK_SIZE))
            .setMaxTransactionFee(new Hbar(2))
            .execute(client)
    ).getReceipt(client);
};

const contractCreateTx = await new ContractCreateTransaction()
    .setGas(6_000_000)
    .setBytecodeFileId(fileId)
    .setMaxTransactionFee(new Hbar(16))
    .execute(client)

const deployRx = await contractCreateTx.getReceipt(client);
console.log("Contract ID:", deployRx.contractId.toString());

After HIP-1086 | Option 1:

Deploying a large smart contract using the Hedera SDK EthereumTransaction.

// --- 1. grab bytecode (<24 KB) ---------------
  const bytecode = "0x" + fs.readFileSync(BYTECODE_PATH, "utf8").trim();

  // --- 2. sign a normal Ethereum create txn ----
  const wallet = new Wallet(process.env.PRIVATE_KEY, provider);
  const signedCreate = await wallet.signTransaction({
    to: null,
    data: bytecode, // full payload goes inline
    nonce: await wallet.getTransactionCount(),
    gasLimit: 3_000_000n // adjust as needed
  });

  // --- 3. wrap & send via HIP-1086 path --------
  const receipt = await (
    await new EthereumTransaction()
      .setEthereumData(Buffer.from(signedCreate.slice(2), "hex"))
      .setMaxGasAllowanceHbar(new Hbar(10)) // adjust as needed
      .setMaxTransactionFee(new Hbar(10)) // adjust as needed
      .execute(client)
  ).getReceipt(client);

  console.log("Contract ID:", receipt.contractId?.toString());

After HIP-1086 | Option 2:

Using only the JSON-RPC Relay (which in turn uses the Hedera SDK EthereumTransaction)

// --- 1. grab bytecode (<24 KB) ---------------
  const bytecode = "0x" + fs.readFileSync(BYTECODE_PATH, "utf8").trim();

  // --- 2. sign a normal Ethereum create txn ----
  const wallet = new Wallet(process.env.PRIVATE_KEY);

  const txResponse = await wallet.sendTransaction({
    data: bytecode,
    gasLimit: 3_000_000n, // adjust as needed
    value: 0,
  });

  console.log("broadcasted:", txResponse.hash);

  // 3. wait for consensus & get the receipt from the mirror
  const receipt = await txResponse.wait();
  console.log("deployed at EVM addr:", receipt.contractAddress);

A Foundation for Continued Innovation

HIP-1086 exemplifies Hedera’s collaborative approach to network evolution, originating from direct feedback from relay operators and developed through community input alongside our ecosystem partners. By combining the familiar EVM development experience with Hedera’s unmatched reliability, predictable fees, and rapid settlement, we are building — and will continue to build — the foundation for the next generation of Web3 applications.

As developers explore these expanded capabilities, they’ll discover that Hedera offers the best of both worlds: seamless compatibility with existing EVM tooling and both the performance amd fairness advantages that only hashgraph consensus can deliver. Whether you’re migrating existing contracts, building new DeFi protocols, or developing enterprise applications, HIP-1086 removes barriers and opens possibilities.

Hello Future.

Resources:

HIP-1086 Documentation: https://hips.hedera.com/hip/hip-1086

Hedera EVM Overview: https://docs.hedera.com/hedera/core-concepts/smart-contracts/understanding-hederas-evm-differences-and-compatibility

Introducing Jumbo Ethereum Transactions: Driving EVM-Compatibility on Hedera was originally published in Hedera Blog on Medium, where people are continuing the conversation by highlighting and responding to this story.