What if your storage model matched your hardware?

// Keys hash to keccak-scattered slots — consecutive
// indices land on different MIP-8 pages.
mapping(uint256 => uint256) private values;

function readEight(uint256 start) external view returns (uint256 sum) {
    for (uint i = 0; i < 8; i++) {
        sum += values[start + i];   // 8 cold-page loads
    }
}

// Adjacent slots — 8 entries fit comfortably in one page.
uint256[256] private values;

function readEight(uint256 start) external view returns (uint256 sum) {
    for (uint i = 0; i < 8; i++) {
        sum += values[start + i];   // 1 cold page + 7 warm
    }
}

The MIP-8 spec predicts a large saving here (8 cold pages → 1 cold + 7 warm, roughly 7× cheaper). Our mainnet measurement shows only a 0.5% difference: 116,281 gas scattered vs 115,729 gas packed. The page-locality charges the spec describes don't appear to differentiate these two layouts at the gas-schedule level on current Monad mainnet. Both tx hashes are linked so you can verify. For now, treat this pattern as forward-compatible (it will likely become a real win as MIP-8's full gas schedule lands), but don't refactor existing contracts expecting an immediate gas drop.

struct User {
    uint256 stake;       // hot
    uint256 _filler0;    // 6 cold fields
    uint256 _filler1;
    uint256 _filler2;
    uint256 _filler3;
    uint256 _filler4;
    uint256 _filler5;
    uint256 lastClaim;   // hot — but 7 slots away
}

// Reading both pays two cold-page loads.

struct User {
    uint256 stake;       // hot
    uint256 lastClaim;   // hot — adjacent
    uint256 _filler0;
    uint256 _filler1;
    uint256 _filler2;
    uint256 _filler3;
    uint256 _filler4;
    uint256 _filler5;
}

// One cold-page load + one warm slot read.

Measured on mainnet: scattered layout (fields 128 slots apart, guaranteed different pages) cost 49,267 gas; reordered layout (fields adjacent) cost 49,292 gas. The reordered version was actually 25 gas more expensive, essentially identical. As with pattern 8a, the page-locality benefit the spec describes doesn't yet materialize at the measured-gas level. The pattern is still good hygiene (cleaner code, better cache behavior off-chain) but isn't currently delivering a measurable on-chain saving.

// Mapping keys hash to slots on different pages.
mapping(uint256 => uint256) private entries;

function allocate(uint256 count, uint256 base) external {
    for (uint i = 0; i < count; i++) {
        entries[i] = base + i;   // each on a new page
    }                            // → count × STATE_GROWTH_COST
}

// Adjacent storage slots — one page covers many entries.
uint256[1024] private entries;

function allocate(uint256 count, uint256 base) external {
    for (uint i = 0; i < count; i++) {
        entries[i] = base + i;   // same page after the first
    }                            // → 1 × STATE_GROWTH_COST
}

Spec prediction: 10 new entries spread across 10 different pages should pay 10 × state-growth (~170k); 10 entries packed into one page should pay 1 × state-growth + 9 × warm-write (~18k). Measured on mainnet: scattered cost 400,500 gas, packed cost 400,017 gas, a 0.1% difference. State growth appears to currently be charged per-slot rather than per-page on Monad mainnet, so the packed layout doesn't yet win. Same recommendation as 8a / 8b: keep this in mind as a forward-compatible improvement, but don't expect today's gas drop.