entropy window

for the first 100 blocks after deployment, the hook applies a multiplier in the range [0.90, 1.10]to every buy's mint amount. the multiplier is deterministic per swap but unpredictable in advance. after block GENESIS_BLOCK + 100, the multiplier is removed forever and buys land exactly on the curve.

the source

function _applyEntropy(uint256 fairSato, address swapper, uint256 ethIn)
    internal view returns (uint256)
{
    if (block.number >= GENESIS_BLOCK + ENTROPY_BLOCKS) return fairSato;
    bytes32 h = keccak256(abi.encodePacked(
        blockhash(block.number - 1), swapper, ethIn
    ));
    uint256 mul = 9000 + (uint256(h) % 2001);   // 9000..11000
    return (fairSato * mul) / 10000;
}

the entropy is the keccak of three things:

• blockhash(block.number − 1)— the most recent finalized blockhash. unknown to anyone constructing the transaction until that block is on chain.
• swapper— the buyer's address, threaded through hookData. two different buyers in the same block get different multipliers.
• ethIn— the exact wei amount of the buy. two buys from the same address at different sizes get different multipliers.

the keccak output is taken mod 2001 and offset to give an integer in [9000, 11000]; the mint is then scaled by mul / 10000. distribution is uniform.

what entropy does not change

the curve

ethCum still advances by the post-fee eth amount the buyer paid. only the sato delivered to the buyer is multiplied. the canonical curve position is unaffected.

totalMintedFair

still tracks the fair-curve supply, not the actual supply. the inverse curve always references this number when pricing sells, so entropy bonuses never let one holder sell ahead of the curve.

sells

sells convert the actual erc-20 input to fair-curve units via satoFairIn = satoIn × totalMintedFair / totalSupply before running the inverse curve. entropy bonuses are socialized into every holder's per-token exit price.

the cap

entropy can raise the actual totalSupply above totalMintedFair, but totalMintedFair is what triggers self-deprecation at 99/100. the asymptote is enforced against the fair curve, not the inflated supply.

why it exists

the early-curve marginal price is the lowest sato will ever trade at. without entropy, a sufficiently capitalized buyer could mass-claim the bottom of the curve in a single block using a flash-loan plus a loop of MAX_BUY_WEI buys. they would still pay the compounding price, but they would face no other competition for the cheapest tickets.

entropy introduces a 20%-band variance on those early mints. a buyer trying to corner the floor now faces a coin-flip on each buy. the expected value is unchanged (the multiplier is centered on 1.0), but the variance scrambles the certainty. it breaks the deterministic optimum and creates a window in which luck matters more than speed.

what an arber sees

the entropy is only revealed when the transaction lands. since it depends on blockhash(block.number − 1), no one constructing a transaction at block N knows what their roll will be at block N. an arbitrageur trying to round-trip within the same block to extract a positive draw is blocked by the COOLDOWN_BLOCKS = 1 same-block sell guard. the arbitrage horizon is at least two blocks wide, and by then the curve has moved.

after the window

from block GENESIS_BLOCK + 100 onward, _applyEntropyreturns its input unchanged. every subsequent mint matches the curve exactly — the only sources of variation in the steady state are the 0.3% fee and rounding at sub-wei precision.