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.
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_sendRawTransactionreturns after the sequencer executes the transaction and includes it in a block.eth_sendRawTransactionSyncreturns the receipt, with itsblockHash, 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_sendRawTransactionreturns the transaction hash once the admits the transaction into its queue.eth_sendRawTransactionSyncreturns 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_sendRawTransaction | eth_sendRawTransactionSync | |
|---|---|---|
| Returns when | The sequencer admits the transaction into its queue | The sequencer executes the transaction |
| Returns | Transaction hash | Transaction receipt, with blockHash set to zero |
| Errors from the admission checks | Yes | Yes |
| Errors at inclusion time | None. The sequencer drops the transaction without a receipt. | Most of them |
| Matches other Ethereum-type chains | Yes | No. 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 and other L2 rollups 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.
| Check | Fails when |
|---|---|
| Nonce already used | The sender has already used this nonce. |
| Insufficient funds | The sender can't pay for the transaction. |
| Fee cap | The transaction's fee cap (maxFeePerGas, the most the sender pays per unit of gas) fails the sequencer's check. |
| Queue full | The 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.
| Cause | What it means |
|---|---|
| Nonce gap | The 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 fee | The transaction's fee cap is below the block's base fee. |
| Queue timeout | The 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 applies only when the node that serves your eth_sendRawTransactionSync call runs 3.13.x. Nitro 3.13.x isn't released yet. If you run the node, also set --execution.rpc.tx-sync-forward=true on it. 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:
| Flag | Default | Description |
|---|---|---|
execution.rpc.tx-sync-default-timeout | 20s | The timeout when the caller doesn't set one. |
execution.rpc.tx-sync-max-timeout | 1m0s | The longest timeout a caller can request. |
The Nitro CLI flags reference lists every flag.
How is this guide?
Nonce management
Understand how Arbitrum handles nonces: the sequencer keeps a short retry window instead of a pending pool, so concurrent submitters must coordinate nonces, and a resubmitted nonce can sometimes return with already known or replacement transaction underpriced.
Migrate transaction submission
Update code that relies on eth_sendRawTransaction returning after inclusion, or on its inclusion-time errors. Switch to eth_sendRawTransactionSync, handle transactions dropped without a receipt, and test the change on Arbitrum Sepolia.