Transaction submission behavior

Learn when eth_sendRawTransaction and eth_sendRawTransactionSync return on Arbitrum chains, which errors each method returns, why a transaction can be dropped without a receipt, and which method to use for latency-sensitive workflows.

Request an update
Rollout status

This behavior rolls out in stages. It reaches Arbitrum Sepolia first and Arbitrum One later. Until the change reaches a chain, the methods on that chain work the old way:

  • eth_sendRawTransaction returns after the sequencer executes the transaction and includes it in a block.
  • eth_sendRawTransactionSync returns the receipt, with its blockHash, after the block is complete.

Arbitrum chains give you two ways to submit a signed transaction. They differ in when they return and what they return:

  • eth_sendRawTransaction returns the transaction hash once the admits the transaction into its queue.
  • eth_sendRawTransactionSync returns a transaction receipt once the sequencer executes the transaction, before the block is complete.

eth_sendRawTransaction tells you quickly that the sequencer has your transaction. eth_sendRawTransactionSync tells you the transaction's outcome in one call. Both help latency-sensitive teams, such as traders, solvers, market makers, arbitrageurs, and decentralized apps.

To update your code for this behavior, see Migrate your transaction submission code.

Compare the two methods

eth_sendRawTransactioneth_sendRawTransactionSync
Returns whenThe sequencer admits the transaction into its queueThe sequencer executes the transaction
ReturnsTransaction hashTransaction receipt, with blockHash set to zero
Errors from the admission checksYesYes
Errors at inclusion timeNone. The sequencer drops the transaction without a receipt.Most of them
Matches other Ethereum-type chainsYesNo. It doesn't comply with EIP-7966.

eth_sendRawTransaction

eth_sendRawTransaction returns the transaction hash once the sequencer admits the transaction into its queue. It doesn't wait for the sequencer to execute the transaction or include it in a block. Ethereum, Base, Monad, and Polygon work the same way.

A successful response means the sequencer admitted the transaction. It doesn't mean the transaction is in a block. You confirm inclusion separately, through a receipt, the , or the sender's nonce.

A revert isn't a submission error. If the transaction reverts, the receipt shows it, with status set to 0x0.

Errors from the admission checks

Before the sequencer admits a transaction, it runs a set of checks. If a check fails, eth_sendRawTransaction returns an error right away.

CheckFails when
Nonce already usedThe sender has already used this nonce.
Insufficient fundsThe sender can't pay for the transaction.
Fee capThe transaction's fee cap (maxFeePerGas, the most the sender pays per unit of gas) fails the sequencer's check.
Queue fullThe sequencer's queue has no room for the transaction.

Transactions dropped without a receipt

A transaction can pass every admission check and still fail when the sequencer builds the block. The sequencer then drops the transaction. eth_sendRawTransaction has already returned the hash, so you get no error. eth_getTransactionReceipt returns null for that hash.

CauseWhat it means
Nonce gapThe transaction's nonce is higher than the sender's next nonce, and the missing transaction doesn't arrive within the retry window. See Nonce management.
Fee cap below base feeThe transaction's fee cap is below the block's base fee.
Queue timeoutThe transaction waits in the sequencer's queue longer than the queue timeout.

eth_sendRawTransactionSync returns most of these errors instead. To detect and resubmit dropped transactions, see Handle transactions with no receipt.

eth_sendRawTransactionSync

eth_sendRawTransactionSync returns a transaction receipt once the sequencer executes the transaction. One call gives you the transaction's status and logs.

It returns sooner than eth_sendRawTransaction did before this change. If your code relied on the old eth_sendRawTransaction returning after inclusion, you can switch to eth_sendRawTransactionSync without slowing your submission path.

The method doesn't wait for the rest of the block. It skips these waits:

  • The time to execute the transactions that follow yours in the block.
  • Any later rounds in the same block. On Arbitrum One, PGA rounds run every 125 ms inside a 250 ms block.
  • The time to finalize the block and save it to disk.

The gain is largest on a chain that runs more than one PGA round per block.

eth_sendRawTransactionSync also returns most of the inclusion-time errors that eth_sendRawTransaction doesn't report.

The early receipt needs an upgraded Nitro node

The early receipt applies only when the node that serves your eth_sendRawTransactionSync call runs 3.14.x. Nitro 3.14.x isn't released yet. A node that isn't upgraded still serves the call, but without the early receipt. This applies to your own nodes and to third-party RPC (remote procedure call) providers. If you use a provider, call web3_clientVersion on its endpoint to check its Nitro version.

The public sequencer endpoint accepts only eth_sendRawTransaction and eth_sendRawTransactionConditional. Send eth_sendRawTransactionSync calls to an RPC node.

The receipt has no block hash

The node returns the receipt before the sequencer finishes building the block. The block doesn't exist yet, so the receipt's blockHash is 0x0000000000000000000000000000000000000000000000000000000000000000.

As a result, eth_sendRawTransactionSync on Arbitrum doesn't comply with EIP-7966. EIP-7966 is the Ethereum Improvement Proposal that defines this method, and it expects a real block hash.

A receipt can be retracted in rare cases

Rarely, a block fails after the sequencer executes a transaction, for example after a disk write error or a sequencer crash. A receipt from eth_sendRawTransactionSync might then not match the canonical chain. The Fast Feed has the same rare failure mode.

eth_getTransactionReceipt returns the canonical receipt, including the blockHash.

Timeouts

The node waits for the receipt up to a timeout. The caller sets the timeout, in milliseconds, as the method's optional second parameter. Node operators limit it with two flags:

FlagDefaultDescription
execution.rpc.tx-sync-default-timeout20sThe timeout when the caller doesn't set one.
execution.rpc.tx-sync-max-timeout1m0sThe longest timeout a caller can request.

The Nitro CLI flags reference lists every flag.

How is this guide?

On this page