EIP-7966 Synchronous transaction submission method (eth_sendRawTransactionSync Method)
No call decision · Networking & nodes · EIP status Draft · created 2025-06-11
Adds a new JSON-RPC method, eth_sendRawTransactionSync, that sends a signed transaction and returns the resulting receipt in a single call.
Why it is needed
Right now, eth_sendRawTransaction is used to send transactions. This method returns only the transaction hash immediately, and to confirm it was actually processed, an app has to separately poll repeatedly until the receipt is available. This polling increases network load and latency and complicates app code. On chains or layer 2s with fast block production, the receipt is often ready as soon as the transaction reaches the block producer, yet an extra query is still needed, creating unnecessary delay. In addition, when a transaction cannot execute immediately due to a nonce gap or insufficient balance, the current error message does not reveal the cause, forcing developers to make an additional call to check account state. This proposal combines submission and receipt retrieval into a single call to cut down on these round trips, aiming to reduce overall submission and confirmation latency by about 50%.
What changes
Today
- Sending a transaction returns only a hash, and the app has to poll separately for the receipt.
- A nonce gap error requires an additional RPC call to find the correct nonce.
- Each app has to implement its own receipt polling logic.
After EIP-7966
- A single call completes both submission and receipt retrieval.
- On a nonce gap, the expected nonce is included immediately in the error response's data field.
- Handled as a single request/response pair, with no polling logic needed.
Who is affected
- Wallet & app developers: Removing receipt polling code and getting the result from a single request simplifies implementation.
- Users: Faster transaction confirmation feedback improves the responsiveness of dapps and wallets.
- Client teams: The new RPC method needs to be implemented, but it is optional, and nodes that haven't implemented it can simply return method not found.
- L2s and high-frequency chains: The effect is greatest in environments with fast block production and low latency. The source states that practicality is lower on chains with high latency, such as mainnet.
In depth
Method name and parameters
The method name is eth_sendRawTransactionSync. The first parameter is the signed transaction of type DATA, which must be in the same hex-encoded RLP encoding format as eth_sendRawTransaction (MUST). The second parameter is an optional maximum wait time in milliseconds, of type INT. The timeout must be a positive integer and must not exceed the maximum timeout set by the node (MUST). If a timeout parameter is provided, the handler must validate it, and must fall back to the node's default timeout if it is invalid (MUST).
Return value and error codes 4, 5, 6
On success, the node must return the transaction receipt object as defined by eth_getTransactionReceipt (MUST). There are three dedicated error codes. Code 4 (Timeout) means the transaction entered the mempool but was not processed within the timeout, with the transaction hash in data. Code 5 (Unknown/Queued) means the transaction was not added to the mempool because it was not ready to execute immediately, with the transaction hash in data. Code 6 (Nonce Gap) means the transaction was not added to the mempool due to a nonce gap, with the expected nonce in data as a hex string (e.g. "0x5"). All other standard errors must follow the existing RPC error format (MUST).
Processing procedure
The handler MUST first check whether a transaction is immediately executable before adding it to the mempool. If the transaction nonce is higher than the expected nonce (a nonce gap), it MUST NOT be added to the mempool, and the handler MUST return code 6 along with the expected nonce. If the transaction becomes pending for any other reason, it also MUST NOT be added to the mempool, and the handler MUST return code 5. If the transaction is immediately executable, it is submitted to the mempool following the existing eth_sendRawTransaction semantics, and the handler waits for the receipt until the timeout elapses. If a receipt is found, it is returned immediately; if the timeout elapses first, the handler MUST return code 4 along with the transaction hash. If the submission itself fails, for example due to malformed transaction data, an error following the eth_sendRawTransaction definition is returned immediately.
Timeout configuration
The handler SHOULD provide a configurable timeout for waiting on the receipt, with a RECOMMENDED default of 2 seconds. Node implementations SHOULD provide a means to configure the timeout length, and node operators MAY adjust the timeout dynamically based on real-time network conditions. The optional timeout parameter passed by the user lets apps set a maximum wait time suited to their own latency requirements while preventing the RPC call from blocking indefinitely.
Why a separate method, and its scope
Modifying the existing eth_sendRawTransaction to add this behavior could cause compatibility issues and semantic ambiguity, so a separate method was created to make the semantics explicit and opt-in. This method does not replace or alter the existing asynchronous submission method, and nodes that do not implement it continue to work normally with the existing approach. The source notes that it is especially well suited to EVM-compatible chains or L2s with fast block production and low network latency, and that on chains with high or variable latency, such as the Ethereum mainnet before sharding, synchronous waiting would extend call duration or trigger timeouts, reducing practicality.
Design: returning the expected nonce in the nonce-gap error
When a transaction is rejected for a nonce gap, the expected nonce is returned as a hex string in the data field of code 6. Since the app obtains the correct nonce directly from the error response, it does not need a separate eth_getTransactionCount call, and it can immediately rebuild and resubmit the transaction with the correct nonce without an extra round trip to query account state. In this case the transaction was never added to the mempool, so no transaction hash is returned.
Implementation approach and security considerations
A minimal implementation can simply wrap the existing eth_sendRawTransaction submission and add logic to wait for the corresponding receipt until the timeout elapses. Receipt availability MAY be obtained either via event notifications or by polling eth_getTransactionReceipt at short intervals. The source includes example handler code for reth, and notes that implementations such as go-ethereum can use a channel to signal receipt arrival instead of polling. From a security standpoint, this does not introduce any new risk beyond what is inherent to transaction submission, and the node-side timeout prevents indefinite blocking. However, implementations must ensure that this does not degrade performance or cause denial of service.
Proposal status
This EIP is in the Interface category of the Standards Track, and its current status is Draft. Since it is still at the draft stage, the method behavior, error codes, and recommended values may change. Because this adds a new RPC method without changing consensus rules, it does not modify or deprecate existing methods, and existing apps using eth_sendRawTransaction are unaffected. The available material contains no record of fork-inclusion discussion at a core developer call.