EIP-8123 Transaction gas limit cap query RPC method (RPC Method for Transaction Gas Limit Cap)
No call decision · Networking & nodes · EIP status Draft · created 2026-01-11
Adds a new JSON-RPC method, eth_txGasLimitCap, that lets you query the maximum gas limit a node will accept for a single transaction.
Why it is needed
EIP-7825 imposed a protocol-level cap on the gas a single transaction can use (2^24 = 16,777,216 on Ethereum). However, it did not define a way to ask a node what that cap is. As a result, wallets and development tools currently have to guess by sending a transaction and seeing it fail, hardcode network-specific values, or dig through client source code or internet documentation. This approach is fragile. The cap may change in future upgrades, and different chains intentionally use different values; for example, Arbitrum and Polygon both use 32,000,000. There are also already proposals to make the cap dynamic based on new fee calculation rules rather than a fixed value. Having a standard way to query the cap lets wallets, SDKs, bundlers, and various tools know the exact limit without simulation or external knowledge.
What changes
Today
- There is no standard way to query the transaction gas cap
- Tools guess the cap from failed sends or hardcode values
- Each chain's different cap must be checked via client source or documentation
After EIP-8123
- A single call to eth_txGasLimitCap reveals the cap the node will accept
- You get the stricter of the protocol cap and the node's own policy, i.e. the value actually enforced
- If there is no cap, you get null, which lets you distinguish that case
Who is affected
- Wallet & app developers: You can query the valid gas cap before building a transaction and set the gas limit within it.
- SDKs, bundlers, tools: Can learn network-specific caps via a standard method instead of hardcoding them.
- Client teams: A new RPC method must be implemented. Existing methods are unchanged.
- L2s and other chains: Chains with different caps, such as Arbitrum and Polygon, can report their own value through the same method.
In depth
New method: eth_txGasLimitCap
The method name is eth_txGasLimitCap and it takes an empty array [] as parameters. The result is QUANTITY or null. If the node enforces a finite transaction gas cap, it MUST return that value as a QUANTITY; if it does not enforce a finite cap, it MUST return null. Null means the node does not limit the gas limit on a per-transaction basis.
Meaning of the return value: min(protocolCap, policyCap)
protocolCap is the maximum tx.gas allowed by the protocol rules active at the node's current head. If EIP-7825 is enabled, this is that value. policyCap is a stricter local cap that the node applies to transaction acceptance (e.g., entry into the transaction pool), and is treated as unlimited if unset. The node MUST return min(protocolCap, policyCap) if it is finite, or null otherwise. It MUST NOT return a value greater than the protocol cap when the protocol cap is finite. The reference implementation pseudocode follows the same logic: it computes both caps separately, takes the smaller one, and returns a value only when it is finite.
Example response
On Ethereum, where the EIP-7825 cap is 2^24, the request {"jsonrpc":"2.0","id":1,"method":"eth_txGasLimitCap","params":[]} returns the result "0x1000000". On a chain where the cap is 32,000,000, the result is "0x1e84800".
Why return the effective cap
Currently there is no way to learn the maximum allowed tx.gas without simulation or external knowledge, which is why a dedicated method is needed. The reason it returns the effective cap min(protocolCap, policyCap), reflecting node policy as well as the protocol cap, is that this is the value a user building and submitting a transaction actually needs.
Backwards compatibility and security
This only adds a new JSON-RPC method and does not change any existing method, so existing clients and applications remain compatible. From a security standpoint, it only exposes information that is already public or that could be learned by sending a transaction, and does not reveal any secrets or user data.
Progress status
This EIP is a Draft-status Standards Track (Interface) proposal, created on January 11, 2026, and requires EIP-7825 (requires: 7825). Since it is still a draft, details such as the method name and return rules may change going forward.