Quick answer: “exceeds block gas limit” means the gas limit you set on a transaction is higher than the maximum gas a single block can hold, so the node refuses to accept it before it is ever mined. No fee is charged. The fix is to lower the transaction’s gas limit below the current block gas limit (50,000,000 gas on Core mainnet when we checked on 19 November 2026), and if your code genuinely needs more than that, split the work into several smaller transactions.
This guide explains where the error comes from in the node software, the exact numbers we measured on Core (chain ID 1116), how it differs from look-alike errors, and step-by-step fixes for wallets, ethers.js, Hardhat and Foundry.
What “exceeds block gas limit” actually means
Every EVM block has a gasLimit field: the total amount of gas all transactions in that block may use together. Every transaction also carries its own gas limit, which is the most it is allowed to burn. A transaction can never be larger than a whole block, so nodes check this before adding a transaction to their mempool.
In go-ethereum, and in Core’s own client core-chain (a Geth-based fork), the check lives in core/txpool/validation.go. If head.GasLimit < tx.Gas(), the pool returns ErrGasLimit, which is defined in core/txpool/errors.go as the literal string "exceeds block gas limit". The same file in upstream go-ethereum uses the identical message. Core-chain also returns the same error if a node operator has set a lower miner “max gas” option and your transaction is above it.
Important detail: this is a rejection, not a failed transaction. Nothing reaches the chain, so there is no transaction hash on Core Scan and no CORE is spent.
What we measured on Core mainnet (19 Nov 2026)
We tested on 19 November 2026 using the public RPC https://rpc.coredao.org and Foundry 1.9.0. We did not broadcast any transaction to mainnet; the “send” tests ran on a local Anvil fork of Core mainnet (see our guide on how to fork Core mainnet with Anvil).
- Block gas limit:
eth_getBlockByNumber("latest")returnedgasLimit= 50,000,000 (block 40,576,636). Spot checks of blocks 20,000,000, 30,000,000, 35,000,000, 39,000,000 and 40,000,000 also showed 50,000,000. - Client:
web3_clientVersionreportedGeth/v1.0.27-…, i.e. the core-chain client. - RPC simulation cap: an
eth_estimateGason an endless-loop contract (injected with a state override) returnedgas required exceeds allowance (20000000). That matches the defaultRPCGasCap: 20000000in core-chain’s eth/ethconfig/config.go.eth_callwith a 60,000,000 gas field did not error on the size; it simply ran out of gas, because the node caps simulation gas instead. - Local fork send: on the Anvil fork (which inherits the 50,000,000 block gas limit), a transfer with
--gas-limit 50000001was rejected withintrinsic gas too high -- tx.gas_limit > env.block.gas_limit, while the same transfer with exactly 50,000,000 was mined successfully, using 21,000 gas.
So the error text depends on the software you are talking to: a Geth-based node such as Core’s RPC says “exceeds block gas limit”, while Anvil phrases the same condition differently. The cause is the same.

Common causes
1. A hard-coded gas limit that is far too high
Scripts often set something like gasLimit: 100_000_000 “to be safe”. On Core, anything above 50,000,000 is refused. Being generous does not help: unused gas is refunded, but a limit above the block cap is never accepted.
2. Gas confused with wei or gwei
Gas is a unit of computation, not money. Passing a gas price value (for example parseUnits("30", "gwei"), which is 30,000,000,000) into the gas limit field produces a number billions of gas high and triggers this error immediately.
3. A padded estimate on a heavy transaction
Tools often multiply the estimate by a safety factor. If a deployment or batch call estimates at, say, 45 million gas, a 20% buffer pushes it past 50 million.
4. Copying settings from another network or a local devnet
Local devnets and other chains can have different block gas limits. A config written for one network may not fit Core. Always read the limit from the network you are actually sending to.
5. Work that really does not fit in one block
Unbounded loops over arrays, giant airdrops in one call, or huge constructor logic can legitimately need more gas than a block holds. No setting fixes that; the code has to change.
How to fix “exceeds block gas limit”
Step 1: Read the current block gas limit
With Foundry:
cast block latest -f gasLimit --rpc-url https://rpc.coredao.org
With ethers.js v6:
const block = await provider.getBlock("latest");
console.log(block.gasLimit); // 50000000n on Core when we checked
Step 2: Let the node estimate, then add a modest buffer
Remove any hard-coded gas limit and estimate first, for example cast estimate or contract.myFunction.estimateGas(...). Add a small buffer (10-20%) and clamp the result so it never goes above the block limit:
const est = await contract.myFunction.estimateGas(arg);
const block = await provider.getBlock("latest");
let gasLimit = (est * 120n) / 100n;
if (gasLimit > block.gasLimit) gasLimit = block.gasLimit;
await contract.myFunction(arg, { gasLimit });
If the estimate itself fails with “gas required exceeds allowance”, read our guide to the gas required exceeds allowance error; on Core’s public RPC the estimate is capped at 20,000,000 gas.
Step 3: Fix the tool configuration
- Hardhat: in the Core network entry, remove a large fixed
gasvalue or set it to"auto". - Foundry: drop
--gas-limitfromcast send/forge script, or set a value below 50,000,000. - Wallets: in MetaMask’s advanced gas settings, reset a manually edited gas limit to the site’s suggestion.
Step 4: If the work really is too big, split it
- Process arrays in batches with a start index and a batch size, across several transactions.
- Move one-off setup out of the constructor into separate initialize calls.
- Split large contracts into libraries or multiple contracts (this also helps with the max code size exceeded limit).
- Use pull-based patterns, such as letting users claim, instead of pushing to thousands of addresses at once.
Step 5: Check you are connected to a synced node
Validation compares your transaction with the node’s current head block. If you run your own node, confirm it is fully synced before sending; for a quick check, compare its block number with the public RPC.
Similar errors and how they differ
| Error | Meaning | Fee charged? |
|---|---|---|
| exceeds block gas limit | Tx gas limit is above the block gas limit | No, rejected |
| intrinsic gas too low | Gas limit is below the minimum cost of the tx | No, rejected |
| gas required exceeds allowance | Estimation needs more gas than the cap or your balance allows | No, not sent |
| out of gas | Mined tx ran past its own gas limit | Yes, on-chain failure |
| transaction gas limit too high | Per-transaction cap from EIP-7825 (Ethereum Osaka) | No, rejected |
The last row is worth knowing if you also deploy to Ethereum. Upstream go-ethereum now enforces a per-transaction cap of 16,777,216 gas (224) from the Osaka fork under EIP-7825, with the error “transaction gas limit too high”. We did not find that constant in core-chain’s params/protocol_params.go when we checked, so on Core the block gas limit is the ceiling that matters. For the opposite problem, a limit set too low, see intrinsic gas too low.
FAQ
What is the block gas limit on Core?
When we checked Core mainnet on 19 November 2026, the latest block and every older block we sampled reported 50,000,000 gas. It can change, so read it live with cast block latest -f gasLimit rather than hard-coding it.
Did I lose CORE when I saw this error?
No. The node rejects the transaction before it enters the mempool, so it is never mined and no fee is paid. You will not find a hash for it on Core Scan.
Can I raise the block gas limit myself?
Not on a public network. The block gas limit is set by the network’s block producers and the client rules. You can only change it on a local chain, for example with Anvil’s --gas-limit flag, which does not affect mainnet.
Why does eth_call work with a huge gas value but sending fails?
Geth-based nodes cap the gas for eth_call and eth_estimateGas with an RPC gas cap (20,000,000 by default in core-chain) instead of rejecting it. Real transactions go through mempool validation, which enforces the block gas limit.
Why do I get it even though my gas limit looks small?
Usually the value is in the wrong unit (wei or gwei instead of gas), or it is a decimal or string the library converted unexpectedly. Log the exact number your code sends.
Disclaimer: This article is for educational purposes only and is not financial or investment advice. Always test on a local fork or testnet before sending real transactions, and never share private keys.
