A smart-contract call that is correct in every other respect can still fail - because it runs out of gas. Ethereum gas is the unit the network uses to measure how much computational work a transaction is allowed to perform. Every transaction carries a gas limit, the maximum amount of work it may consume before execution stops. That makes gas both a metering system and a safety valve: when the limit runs out, the transaction - or a nested contract call inside it - can fail even though the underlying code is valid.
Table of contents
- Plain-language definition
- How Ethereum gas works step by step
- Where gas assumptions show up in practice
- Limits, costs, failure modes, and real-world upgrade risk
- How this relates to Assetara products
- FAQ
Plain-language definition

Gas is Ethereum's way of pricing computation and limiting it at the same time. Every operation inside the Ethereum Virtual Machine (EVM) consumes a measured amount of gas, and the person sending a transaction sets the maximum amount they're willing to spend. Once execution needs more gas than that, it stops.
Gas isn't just about cost, though. It can also determine what happens inside a smart contract when one contract calls another. A call that receives too little gas can fail outright, and it's the calling contract's own code that decides whether that failure gets caught, passed along, or routed into a different branch of execution.
How Ethereum gas works step by step
1. A user signs a transaction in a wallet. The transaction names a destination address, can carry data and value, and specifies a gas limit.
2. The network includes the transaction in a block. Once execution begins, the EVM starts with the gas attached to the transaction and deducts gas as each piece of work is carried out.
3. Each EVM operation consumes gas - reading or writing contract storage, running calculations, checking conditions, and calling other contracts all cost gas.
4. If the transaction reaches a smart contract, that contract runs inside the current execution frame - the active layer of code being executed at that moment.
5. If the contract makes an external call, the called contract receives its own allocation carved out of the remaining gas. How much gets forwarded depends on the calling code and on protocol rules that cap what can be passed along.
6. The called contract then either finishes successfully, reverts, hits an invalid operation, or runs out of gas. Whatever happens is passed back to the caller as success or failure, sometimes along with return data.
7. The caller decides what happens next. It can stop and revert the entire transaction, ignore the failure and keep going, or follow a fallback path - if its code was written to allow one.
8. If the whole transaction completes successfully, its state changes are committed. If it fails at the transaction level, the attempted state changes are rolled back - but the gas already spent on execution is not refunded.
One way to picture this: think of the transaction as a total project budget split across tasks, where a nested call is a subcontracted task that only gets part of that budget. If the subcontractor runs out, the main project can either stop or continue, depending on how it was planned. The metaphor helps with intuition, but it's worth remembering that the EVM is accounting for protocol work, not money changing hands between parties.
Where gas assumptions show up in practice
Gas assumptions matter wherever one contract depends on another, or on code that might run during the receipt of value. That covers payment flows, token distribution, auctions, governance execution, liquidation systems, bridges, and batch-processing workflows.
A common pattern is a contract that pays many recipients inside one loop. If a single recipient's callback uses more gas than expected, or reverts outright, the distributor faces a choice: stop the whole batch, skip that recipient, or record a balance for later withdrawal. Each option trades off fairness, completion, and complexity differently.
Another pattern is retry logic, where a contract treats a failed call as temporary and tries again later. That works fine if the failure was caused by something transient - but it can misbehave if a protocol change alters when the failure occurs or how it gets reported.
The reporting underlying this article describes one concrete compatibility concern: ChainSecurity identified 13 deployed contracts whose behavior could be disrupted by proposed gas changes involving EIP-8037 and EIP-8038. No financial losses had been reported at that time.
Limits, costs, failure modes, and real-world upgrade risk
Gas limits exist to stop Ethereum from accepting unlimited computation. Without them, network participants could be forced to process work too expensive to verify. That same safeguard creates the trade-off many users run into: complex transactions can fail outright, and even a failed attempt still consumes gas.
Common failure modes include an underfunded transaction gas limit, too little gas forwarded to a nested call, incorrect error handling, deliberate gas griefing, and batch-processing limits. In plain terms: a workflow can fail because the top-level transaction didn't carry enough gas, because a nested call received too little, because the developer assumed the wrong failure behavior, because someone deliberately made the workflow expensive to run, or because too many items were packed into a single transaction.
The reported Hoodi case is a testnet postponement, not a mainnet loss event. The Ethereum Foundation Blog said the Glamsterdam upgrade on Hoodi - previously scheduled for October 26, 2026 - was postponed, and that no new activation date had been set, as of its November 3, 2026 update.
Cointelegraph and Yahoo Finance reported that the delay followed gas-related security concerns raised by ChainSecurity. Their reporting said the concern wasn't that gas is new, but that proposed gas changes could alter how existing contracts handle failures - including cases where a retryable failure could turn into a permanent outcome under some designs.
That kind of risk matters because deployed contracts usually can't rewrite themselves. If protocol rules change how much gas a step costs, or when a call fails, a contract built around the old behavior may take a different branch than its developers expected. The sources available here don't prove that every contract is affected, don't establish a mainnet incident, and don't include the full technical specifications needed for a contract-by-contract audit.
The costs here aren't only technical - they also include testing, review, and operational delay. Developers may need to re-check fixed gas assumptions, low-level call handling, retry paths, and batch logic before deploying or upgrading software that depends on Ethereum's execution behavior.
The source material doesn't report any losses from the Hoodi postponement. What it reports is a delay meant to give developers more time to review compatibility before activation.
How this relates to Assetara products
The sources used for this article don't identify an Assetara product, contract address, supported Ethereum asset, or compatibility notice. Nor do they support any claim that a specific Assetara offering is affected by the Hoodi postponement.
For Assetara readers, the factual takeaway here is about process, not promotion: if a product depends on Ethereum contracts, its behavior can change when gas rules, call behavior, or failure handling change. Whether that matters for any specific product requires checking product documentation, contract review, and official notices from the relevant team.
FAQ
Does running out of gas always mean funds are lost?
No. If a transaction runs out of gas, its attempted state changes are generally reverted. The gas already spent on execution isn't refunded, but that's different from losing the underlying asset in every case.
Can a contract keep going after another contract fails?
Sometimes. If the caller still has gas left and its code is written to handle the failure, it can continue. If it propagates the error, or runs out of gas itself, the larger transaction may fail.
Why can a protocol gas change affect a deployed contract?
Deployed contracts execute under the network's current rules. If those rules change the gas cost of an operation, or change how failures surface, code written for the old behavior may follow a different path - or fail at a different point - than before.
Did the Hoodi postponement mean user funds were lost?
No, the sources available here don't report any user-fund losses. They report a postponement of the Hoodi activation after compatibility concerns were raised.
What should a reader check after a testnet upgrade is delayed?
Check the official network update, the specific application's own notices, and any compatibility guidance from the team behind the contract. A delay is a signal to verify current behavior - not proof that every Ethereum application is affected.



