integer-overflow

Integer Safety

Solidity 0.8+ Automatic Checks

Since Solidity 0.8, arithmetic operations revert on overflow/underflow by default. This eliminates the need for SafeMath but introduces new considerations.

// These all revert automatically on overflow (Solidity 0.8+)
uint256 a = type(uint256).max;
uint256 b = a + 1;  // reverts: arithmetic overflow

uint256 c = 0;
uint256 d = c - 1;  // reverts: arithmetic underflow

uint8 e = 255;
uint8 f = e + 1;    // reverts: arithmetic overflow

Unchecked Blocks

Use unchecked when overflow is mathematically impossible and gas savings matter.

// SAFE: loop counter cannot overflow (bounded by array length)
for (uint256 i; i < arr.length;) {
    processItem(arr[i]);
    unchecked { ++i; }
}

// SAFE: subtraction will not underflow (checked by prior condition)
function withdraw(uint256 amount) external {
    uint256 balance = balances[msg.sender];
    if (balance < amount) revert InsufficientBalance();

    unchecked {
        balances[msg.sender] = balance - amount; // balance >= amount guaranteed
    }
}

// SAFE: hash computation (intentional wrapping)
unchecked {
    uint256 hash = uint256(keccak256(abi.encodePacked(a))) + nonce;
}

When Unchecked Is Dangerous

// DANGEROUS: user-controlled values in unchecked
unchecked {
    uint256 result = userInput1 + userInput2; // could overflow silently
}

// DANGEROUS: complex arithmetic with multiple operations
unchecked {
    uint256 result = (a * b + c) / d; // any step could overflow
}

Phantom Overflow

Intermediate calculations can overflow even when the final result fits.

// VULNERABLE: a * b can overflow even if (a * b) / c fits in uint256
function mulDiv(uint256 a, uint256 b, uint256 c) internal pure returns (uint256) {
    return a * b / c; // reverts if a * b > type(uint256).max
}

// Example: mulDiv(2e18, 3e18, 1e18) should return 6e18
// But 2e18 * 3e18 = 6e36, which overflows uint256? No, 6e36 < 2^256
// But mulDiv(type(uint128).max, type(uint128).max, 1) WILL overflow

// FIXED: use Solmate's FixedPointMathLib which handles phantom overflow
import {FixedPointMathLib} from "solmate/utils/FixedPointMathLib.sol";

function mulDiv(uint256 a, uint256 b, uint256 c) internal pure returns (uint256) {
    return FixedPointMathLib.mulDiv(a, b, c); // assembly-based, no phantom overflow
}