Ethereum transaction

​

Supported transaction types

​

Access Lists (EIP-2930)

access_list = [
  { address: "0x<contract>", storageKeys: ["0x<slot1>", "0x<slot2>", ...] },
  { address: "0x<another>",  storageKeys: [] },
  ...
]

• Cross-contract calls where the EVM doesn’t already know about the target address. Listing it converts a 2,600-gas cold CALL into a 100-gas warm one.
• Reads of storage slots in another contract (a token balance lookup, a registry probe). Listing the slot converts a 2,100-gas cold SLOAD into a 100-gas warm one.

• Slots in the contract that owns the transaction’s to address are warm anyway (the contract’s own storage is pre-warmed).
• Speculative listings of slots that never get read. You still pay the access-list overhead (2,400 per address + 1,900 per slot) without recouping the cold-access discount.

​

Example: hand-built Type 1 transaction (ethers v6)

import { Wallet, JsonRpcProvider, Transaction } from "ethers";

const provider = new JsonRpcProvider("https://testnet.hashio.io/api");
const wallet   = new Wallet(process.env.OPERATOR_KEY, provider);

const tx = new Transaction();
tx.type     = 1;                               // EIP-2930
tx.chainId  = 296n;                            // Hedera testnet
tx.to       = "0x<router-address>";
tx.value    = 0n;
tx.gasLimit = 200_000n;
tx.gasPrice = (await provider.getFeeData()).gasPrice;
tx.nonce    = await provider.getTransactionCount(wallet.address);
tx.data     = "0x<encoded-call-data>";
tx.accessList = [
  {
    address: "0x<token-contract>",
    storageKeys: [
      // balanceOf slot
      "0x0000000000000000000000000000000000000000000000000000000000000003",
      // allowance slot
      "0x0000000000000000000000000000000000000000000000000000000000000004", 
    ],
  },
];

const signed = await wallet.signTransaction(tx);
const sent   = await provider.broadcastTransaction(signed);
console.log("tx hash:", sent.hash);

​

Example: Type 2 with access list (viem)

import { createWalletClient, http, parseGwei } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { hederaTestnet } from "viem/chains";

const account = privateKeyToAccount(process.env.OPERATOR_KEY);
const client  = createWalletClient({ chain: hederaTestnet, transport: http(), account });

const hash = await client.sendTransaction({
  type: "eip1559",
  to: "0x<router-address>",
  data: "0x<encoded-call-data>",
  // example value; query eth_gasPrice for the live rate (Hedera's gas price is network-determined)
  maxFeePerGas: parseGwei("710"), 
  // ignored on Hedera; fees are network-determined
  maxPriorityFeePerGas: 0n,       
  accessList: [
    {
      address: "0x<token-contract>",
      storageKeys: [
        "0x0000000000000000000000000000000000000000000000000000000000000003",
      ],
    },
  ],
});

Tip: Most JSON-RPC providers expose eth_createAccessList; call it against a simulated transaction to get a near-optimal access list before signing.

​

Hedera specifics

• The warm/cold discount is honored. Hedera applies the same EIP-2929/2930 gas accounting as Ethereum, so listed addresses and slots are charged at the warm rate on first touch. The exact cold/warm opcode costs are in the gas schedule.
• access_list also rides on Type 4 transactions. The EIP-7702 payload carries both access_list and authorization_list, so you can pre-warm storage and set EOA code delegation in a single transaction. See EOA Code Delegation.
• Access-list bytes count toward the EIP-7623 calldata floor. A large speculative access list increases callData size and can push a low-execution transaction into the calldata floor; list only slots you’ll actually touch.
• Submitting via the SDK. Pass the raw signed RLP (Type 1 or Type 2) as ethereumData on an EthereumTransaction; Hedera preserves the access list during execution. No Hedera-native field mirrors access_list; it lives entirely inside the RLP payload.

​

Handling Large callData Payloads

​

Gas Calculation for callData

callData gas = 4 × zero bytes + 16 × non-zero bytes

​

Quick reference: Jumbo vs Standard Transactions

​

Transaction Signing Requirements

• The account with the ECDSA alias derived from the public key in ethereumData, if sufficient gas and fees are authorized.
• If the authorized fee from the Ethereum sender is insufficient, the payer of the transaction is charged up to the maxGasAllowance.
• For jumbo transactions, ensure the payer’s key is included and maxGasAllowance is set high enough to cover potential gas and fees.

​

Transaction Fees

• Base transaction fee
• Gas for callData, (calculated as: 4 × zero bytes + 16 × non-zero bytes)
• Execution gas determined by EVM smart contract logic

//Create the transaction
EthereumTransaction transaction = new EthereumTransaction()
     .setEthereumData(ethereumData)
     .setMaxGasAllowanceHbar(allowance);

//Sign with the client operator private key to pay for the transaction and submit the query to a Hedera network
TransactionResponse txResponse = transaction.execute(client);

//Request the receipt of the transaction
TransactionReceipt receipt = txResponse.getReceipt(client);

//Get the transaction consensus status
Status transactionStatus = receipt.status;

System.out.println("The transaction consensus status is " +transactionStatus);

//v2.14

//Create the transaction
const transaction = new EthereumTransaction()
     .setEthereumData(ethereumData)
     .setMaxGasAllowance(allowance);

//Sign with the client operator private key to pay for the transaction and submit the query to a Hedera network
const txResponse = await transaction.execute(client);

//Request the receipt of the transaction
const receipt = await txResponse.getReceipt(client);

//Get the transaction consensus status
const transactionStatus = receipt.status;

console.log("The transaction consensus status is " +transactionStatus);

//v2.14

//Create the transaction
transaction, err := hedera.NewEthereumTransaction().
     SetEthereumData(ethereumData)
     SetGasAllowed(allowance)

//Sign with the client operator private key to pay for the transaction and submit the query to a Hedera network
txResponse, err := transaction.Execute(client)
if err != nil {
	panic(err)
}

//Request the receipt of the transaction
receipt, err := txResponse.GetReceipt(client)
if err != nil {the 
	panic(err)
}

//Get the transaction consensus status
transactionStatus := receipt.Status

fmt.Printf("The transaction consensus status %v\n", transactionStatus)

//v2.14