Skip to content
PenyuOnCore
Menu
  • Home
  • Core Ecosystem Analysis
  • Personal Finance & Investing
  • Make Money Online
  • Bitcoin
  • About Us
Menu
Exceeds block gas limit error explained: tx gas above block gasLimit, Core mainnet block gas limit 50,000,000, check with cast block latest -f gasLimit

“Exceeds Block Gas Limit” Error: What It Means and How to Fix It

Posted on November 18, 2026

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") returned gasLimit = 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_clientVersion reported Geth/v1.0.27-…, i.e. the core-chain client.
  • RPC simulation cap: an eth_estimateGas on an endless-loop contract (injected with a state override) returned gas required exceeds allowance (20000000). That matches the default RPCGasCap: 20000000 in core-chain’s eth/ethconfig/config.go. eth_call with 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 50000001 was rejected with intrinsic 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.

Diagram of three gas ceilings on Core: 50,000,000 block gas limit gives exceeds block gas limit, 20,000,000 RPC estimate cap gives gas required exceeds allowance, and your own tx gas limit gives out of gas

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 gas value or set it to "auto".
  • Foundry: drop --gas-limit from cast 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

ErrorMeaningFee charged?
exceeds block gas limitTx gas limit is above the block gas limitNo, rejected
intrinsic gas too lowGas limit is below the minimum cost of the txNo, rejected
gas required exceeds allowanceEstimation needs more gas than the cap or your balance allowsNo, not sent
out of gasMined tx ran past its own gas limitYes, on-chain failure
transaction gas limit too highPer-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.

Recent Posts

  • “ERC20: Transfer Amount Exceeds Balance” Error: What It Means and How to Fix It
  • “Exceeds Block Gas Limit” Error: What It Means and How to Fix It
  • How to Change Your TreasuryDirect Bank Account (2026 Guide)
  • How to Fork Core Mainnet with Anvil for Local Testing (2026)
  • Spring Payout After Shutdown: How to Get Your Remaining Teespring Balance (2026)
Subscription form is not available at the moment
  • Altcoin News
  • Bitcoin
  • Core Ecosystem Analysis
  • DeFi
  • Free Crypto Signals
  • Make Money Online
  • Personal Finance & Investing
  • Token Analysis
  • About Us
  • Contact
  • Privacy Policy
  • Disclaimer
©2026 PenyuOnCore | Design: Newspaperly WordPress Theme