Gas Metering¶

Understanding and working with gas costs in Zig EVM.

What is Gas?¶

Gas is the unit of computational effort in the EVM. Every operation costs gas, and transactions must include enough gas to complete execution.

Purpose of Gas¶

Gas Costs¶

Base Costs by Category¶

Arithmetic Operations¶

STOP      => 0
ADD, SUB  => 3
MUL, DIV  => 5
MOD       => 5
ADDMOD    => 8
MULMOD    => 8
EXP       => 10 + 50 * byte_size(exponent)

Stack Operations¶

POP      => 2
PUSH1-32 => 3
DUP1-16  => 3
SWAP1-16 => 3

Memory Operations¶

MLOAD    => 3 + memory_expansion_cost
MSTORE   => 3 + memory_expansion_cost
MSTORE8  => 3 + memory_expansion_cost
MSIZE    => 2

Storage Operations¶

// SLOAD
Cold access    => 2100
Warm access    => 100

// SSTORE
Set (0 -> non-0)     => 20000
Reset (non-0 -> non-0) => 5000
Clear (non-0 -> 0)    => 5000 (+ 4800 refund)
No-op (same value)    => 100

Call Operations¶

CALL, STATICCALL, DELEGATECALL => 100 + memory_cost + value_transfer
CREATE  => 32000 + code_deposit
CREATE2 => 32000 + hash_cost + code_deposit

Memory Expansion Cost¶

Memory gas grows quadratically to prevent excessive memory use:

memory_cost = (memory_size_words * 3) + (memory_size_words² / 512)

Example:

Setting Gas Limits¶

from zigevm import EVM

evm = EVM()

# Set gas limit for execution
evm.set_gas_limit(1000000)

result = evm.execute(code)

print(f"Gas used: {result.gas_used}")
print(f"Gas remaining: {result.gas_remaining}")

const { EVM } = require('zigevm');

const evm = new EVM();

// Set gas limit for execution
evm.setGasLimit(1000000n);

const result = evm.execute(code);

console.log(`Gas used: ${result.gasUsed}`);
console.log(`Gas remaining: ${result.gasRemaining}`);

EVMHandle evm = evm_create();

// Set gas limit for execution
evm_set_gas_limit(evm, 1000000);

EVMResult result = evm_execute(evm, code, code_len, NULL, 0);

printf("Gas used: %lu\n", result.gas_used);
printf("Gas remaining: %lu\n", result.gas_remaining);

Out of Gas Handling¶

When gas is exhausted:

1. Execution halts immediately
2. All state changes are reverted
3. OutOfGas error is returned
4. Consumed gas is not refunded

result = evm.execute(code)

if not result.success and result.error_code == 1:  # OutOfGas
    print("Out of gas!")
    print(f"Gas used before failure: {result.gas_used}")

const result = evm.execute(code);

if (!result.success && result.errorCode === 1) {  // OutOfGas
    console.log('Out of gas!');
    console.log(`Gas used before failure: ${result.gasUsed}`);
}

Gas Estimation¶

Estimate gas before execution:

# Start with a high gas limit
evm.set_gas_limit(10_000_000)

result = evm.execute(code)

if result.success:
    estimated_gas = result.gas_used
    # Add 10% buffer for safety
    recommended_gas = int(estimated_gas * 1.1)
    print(f"Recommended gas limit: {recommended_gas}")

Gas Refunds¶

Certain operations provide gas refunds:

Maximum refund: Capped at 20% of total gas used (post-EIP-3529).

Intrinsic Gas¶

Transaction base costs:

EIP-2929 Access Lists¶

Cold/warm access model for addresses and storage:

Cold address access:   2600 gas
Warm address access:   100 gas

Cold storage access:   2100 gas
Warm storage access:   100 gas

First access to an address or storage slot is "cold" and costs more.

Gas Optimization Tips¶

1. Minimize Storage Operations¶

Storage is expensive. Cache values in memory:

// Bad: Multiple SLOADs
for (uint i = 0; i < array.length; i++) {
    total += array[i];  // SLOAD each iteration
}

// Good: Single SLOAD
uint len = array.length;  // SLOAD once
for (uint i = 0; i < len; i++) {
    total += array[i];
}

2. Pack Storage¶

Use smaller types to pack multiple values in one slot:

// Bad: 3 storage slots
uint256 a;
uint256 b;
uint256 c;

// Good: 1 storage slot
uint128 a;
uint64 b;
uint64 c;

3. Short-Circuit Conditions¶

Order conditions by likelihood and cost:

// Bad: Expensive check first
if (expensiveCheck() && cheapCheck()) { ... }

// Good: Cheap check first
if (cheapCheck() && expensiveCheck()) { ... }

4. Use Memory over Storage¶

Memory is much cheaper than storage:

// Bad: Modify storage directly
storageArray.push(value);

// Good: Build in memory, then store
uint[] memory temp = new uint[](length);
// ... fill temp ...
storageArray = temp;

Gas Cost Reference Table¶