Gas and Optimization

// BAD — 3 storage slots
struct Wasteful {
    uint256 a;   // slot 0
    uint8   b;   // slot 1 (wastes 31 bytes)
    uint256 c;   // slot 2
}

// GOOD — 2 storage slots
struct Packed {
    uint256 a;   // slot 0
    uint8   b;   // slot 1 (byte 0)
    uint8   c;   // slot 1 (byte 1)
    uint240 d;   // slot 1 (bytes 2–31)
}

// BAD — SLOAD on every iteration
for (uint i; i < items.length; ++i) { // items.length = SLOAD each time
    total += items[i]; // SLOAD each time
}

// GOOD — 1 SLOAD for length, fewer for items
uint256 len = items.length;
for (uint i; i < len; ++i) {
    total += items[i];
}

// constant — compiler-inlined, zero SLOAD
uint256 constant MAX = 10_000;

// immutable — stored in bytecode, CODECOPY instead of SLOAD
address immutable public factory;

// Regular state variable — SLOAD (2100 cold, 100 warm)
address public factorySlow;

// Setting to non-zero costs 22 100 gas (cold slot)
// Setting non-zero → non-zero costs 2 900 gas (warm)
// Setting to zero costs 5 000 gas but gives 4 800 refund
// Use 1/2 instead of false/true for reentrancy guards:

uint256 private _locked = 1; // non-zero init
modifier nonReentrant() {
    require(_locked == 1);
    _locked = 2; // non-zero → non-zero: cheap
    _;
    _locked = 1; // non-zero → non-zero: cheap
}

// 0.8+ checks overflow by default — adds ~80-200 gas per op
// Use unchecked when you can PROVE no overflow:

function sum(uint256[] calldata arr) external pure returns (uint256 total) {
    uint256 len = arr.length;
    for (uint256 i; i < len;) {
        unchecked {
            total += arr[i]; // no overflow check
            ++i;             // no overflow check on loop counter
        }
    }
}

// cheapest for external array inputs: calldata (no copy)
function processCalldata(uint256[] calldata data) external pure { }

// memory: copied from calldata, mutable but costs more
function processMemory(uint256[] memory data) public pure { }

// storage pointer: references state — no copy, but SLOAD/SSTORE
function processStorage() external {
    uint256[] storage ref = myArray; // pointer, not a copy
}

// Put cheapest / most likely to fail check FIRST
function check(address token, address user, uint256 amount) external view returns (bool) {
    return amount > 0                     // cheap: no SLOAD
        && amount <= MAX_AMOUNT           // cheap: constant
        && IERC20(token).balanceOf(user) >= amount; // expensive: external call
}

// SSTORE (non-zero): 22 100 gas
// LOG3 (3 topics + 32 bytes data): ~2 000 gas

// Use events for historical/audit data you don't need on-chain:
event Transfer(address indexed from, address indexed to, uint256 value);

// Only store what you actually need to read on-chain
mapping(address => uint256) public balances; // needed for on-chain logic
// transaction history → use events, NOT storage

// Prefer ++i over i++ (saves 1 gas — no temp copy)
for (uint i; i < len; ++i) { }

// Cache array length
uint256 n = arr.length;
for (uint i; i < n; ++i) { }

// Reverse loop (avoids comparison with non-zero for uint)
for (uint i = arr.length; i != 0;) {
    unchecked { --i; }
    process(arr[i]);
}

// Each zero byte in calldata = 4 gas; non-zero = 16 gas (EIP-2028)
// Prefer function args that produce many zero bytes where possible
// This is why many protocols left-shift addresses and amounts

// bytes32: fixed size, 1 storage slot, no dynamic allocation
bytes32 public constant NAME = "MyToken"; // cheap

// string: dynamic, pointer + length, 2+ SLOADs for short strings
string public name = "MyToken"; // expensive to read/compare

// Pack multiple values into one uint256 to save slots
// e.g., uint128 price + uint128 tokenId in one 256-bit word

uint256 packed;

function setPricedToken(uint128 price, uint128 tokenId) external {
    packed = (uint256(price) << 128) | uint256(tokenId);
}

function getPrice() external view returns (uint128) {
    return uint128(packed >> 128);
}

function getTokenId() external view returns (uint128) {
    return uint128(packed);
}

// Functions with selectors starting with 0x00 are ~22 gas cheaper per call
// (4 zero bytes in calldata vs 4 non-zero bytes)
// Solidity/Yul miners sometimes reorder selectors for savings (niche)

// Called off-chain (eth_call) = ZERO gas
function getBalance(address user) external view returns (uint256) {
    return balances[user];
}

// But called internally from a state-changing tx: costs normal gas

// Leave buffer in gas limit:
// actual_gas_used < gas_limit or tx fails (OOG)

// Gas reporting in Foundry:
// forge test --gas-report
// forge snapshot --check

// Foundry invariant test:
// assertLt(gasleft() after op, EXPECTED_LIMIT);

// Deploy cheap clones of a contract — 45-byte bytecode proxy
// Each clone delegates all calls to the implementation

// OpenZeppelin Clones library:
address clone = Clones.clone(implementation);
// Or with salt for deterministic address:
address clone2 = Clones.cloneDeterministic(implementation, salt);