StonkTower

$STONKTOWER is an ERC-20 that is its own Uniswap v4 hook, paired to SPYon on Ethereum. Every holder above 0.05% of supply lives on one of six floors. Trading volume prints raids; a raid takes a cut from one resident, pays the raider, feeds the Stonkers pool and burns the rest. Sells pay dividends to every holder. No keeper and no timer — raids run off the order flow and nothing else.

Floors

Floors are balance bands measured in whole tokens and fixed at launch. They do not drift as supply burns, so the ladder you see today is the ladder forever. Below 500 tokens you sit in the lobby: you still collect dividends, you just do not play.

// balance bands, in whole tokens (×1e18 on chain)
uint128[6] constant FLOORS = [500e18, 1_000e18, 2_000e18, 5_000e18, 10_000e18, 20_000e18];
uint128 constant SAFE_FLOOR = 500e18;

function floorOf(uint128 bal) internal pure returns (uint8) {
    if (bal < SAFE_FLOOR) return 0;
    for (uint8 f = 6; f > 0; f--) if (bal >= FLOORS[f - 1]) return f;
    return 0;
}

Raids

There is no clock. The hook watches its own pool and every 1.5 SPYon of cumulative volume drops one raid into the queue, which holds four at most. A quiet week cannot bank a hundred raids and dump them at once. Trade and the tower wakes up; stop trading and it sleeps.

The contract commits, not a person. A raid is armed inside the swap that printed it and settled four or more blocks later by the next buy — up to four raids in a single buy. Raids never settle inside a sell: in v4 the router takes the sold tokens after the hook runs, so cutting the seller mid-sale would revert the whole transaction. The seed is the hash of a block that did not exist when the raid was armed, so nobody can aim it and nobody can front-run it — and there is no target to block, because nobody names one.

uint256 constant EAT_UNIT    = 1.5e18;   // SPYon of volume per raid
uint8   constant MAX_PENDING = 4;
uint64  constant COMMIT_LAG  = 4;

function _afterSwap(uint256 volumeSpy) internal {
    cumulativeVolume += volumeSpy;
    while (cumulativeVolume >= nextRaidAt) {
        nextRaidAt += EAT_UNIT;
        if (pendingRaids < MAX_PENDING) pendingRaids++;
    }
    if (pendingRaids > 0 && commitBlock == 0) commitBlock = uint64(block.number);
    _settle();
}

Who gets picked

The target is drawn uniformly from every resident on the board — not floor first, then resident. That single choice is what keeps the tower honest: splitting a whale into forty wallets buys forty times the tickets and forty times smaller haircuts, and the two cancel out exactly. Weighting the draw by size would do the opposite and pay people to split. The raider is then drawn from the target's own floor or the floor below, which caps the size gap between the two at roughly 4×.

function _raid(uint256 seed) internal {
    uint256 n = live.length;
    uint256 i = seed % n;                                // uniform over residents
    address target;
    for (uint8 k = 0; k <= MAX_REDRAWS; k++) {           // skip lock-ups and poison pills
        address c = live[(i + k) % n];
        if (_inPlay(c)) { target = c; break; }
    }
    if (target == address(0)) return;                     // raid stays queued

    uint8 f = floorOf(balanceOf[target]);
    address raider = _drawFrom(f, f == 1 ? 1 : f - 1, seed >> 128, target);
    if (raider != address(0)) _haircut(raider, target);
}

The haircut

A raid takes up to 20% of the target's balance. Of that balance, 10% goes to the raider, 7% to the Stonkers pool and 3% is burned — in shares of the haircut itself that is 50 / 35 / 15. The raider's reward is a share of the haircut, never a fixed bounty: a fixed bounty would make it profitable to raid your own dust wallet, a share makes that a guaranteed loss.

The raider's cut is not pushed to their balance: it waits in a claimable bucket, so the raider's floor and mark do not move at the moment of the raid. Several bounties can be claimed in one transaction. Leave a bounty unclaimed for 24 hours and anyone can sweep it into the Stonkers pool. Claiming adds the tokens to your balance without moving your mark — which puts you above your line and back in play.

uint16 constant BITE_BPS     = 2000;   // 20% of the target, at most
uint16 constant MIN_BITE_BPS = 200;    // below 2% the raid does not land
uint16 constant TO_RAIDER    = 5000;   // of the haircut
uint16 constant TO_STONKERS  = 3500;
uint16 constant TO_BURN      = 1500;

mapping(address => uint256) public bountyOf;

function _haircut(address raider, address target) internal returns (bool) {
    uint128 bal  = balanceOf[target];
    uint128 bite = bal * BITE_BPS / 10_000;
    uint128 room = bal - _line(target);                     // never below the line
    if (bite > room) bite = room;
    if (bite < bal * MIN_BITE_BPS / 10_000) return false;   // dust cannot reopen a target

    uint128 toRaider   = bite * TO_RAIDER   / 10_000;
    uint128 toStonkers = bite * TO_STONKERS / 10_000;
    _take(target, bite);
    bountyOf[raider] += toRaider;                            // claimable, 24 h before sweep
    stonkersPool     += toStonkers;
    _burn(bite - toRaider - toStonkers);
    // marks are untouched: the target now sits on its line, the raider has not moved
    emit Raid(raider, target, bite);
    return true;
}

Poison pill

Every resident carries a mark: their balance as of their last own move. A raid can only land while the balance sits above mark minus 20%. Once raided you drop exactly to the line and the pill holds — nobody can raid you again until you buy, sell or transfer, because any of those resets the mark to your new balance. An incoming transfer does not move your mark, and a raid needs at least 2% of balance above the line to land, so a dust gift cannot reopen you.

mapping(address => uint128) public mark;

function _line(address a) internal view returns (uint128) {
    return mark[a] * (10_000 - BITE_BPS) / 10_000;
}
function _inPlay(address a) internal view returns (bool) {
    return balanceOf[a] >= SAFE_FLOOR
        && block.timestamp >= bornAt[a] + LOCKUP
        && balanceOf[a] > _line(a);
}
// own moves reset the mark; receiving a transfer does not
if (from == POOL)    mark[to]   = balanceOf[to];     // buy
else                 mark[from] = balanceOf[from];   // sell or outgoing transfer

Lock-up

A fresh buy carries a five-minute lock-up: you cannot be raided and you cannot raid. The stamp is set only on a buy from the pool, never on an incoming transfer, so hopping to a fresh wallet does not refresh it. The raider needs the same five minutes — no buy, raid and sell in one breath.

uint64 constant LOCKUP = 5 minutes;
if (from == POOL) bornAt[to] = uint64(block.timestamp);   // on a buy only

Fees & dividends

Every swap pays 5%. On a buy the fee is taken in $STONKTOWER and burned. On a sell the fee is taken in SPYon and goes to holders by balance, all of it. Dividends accrue to every holder, lobby included — the game is for residents, the yield is for everyone. A sell fee is booked on the next swap, after the seller's balance has dropped, so nobody earns a share of their own fee.

Claim whenever you like, in one transaction. One rule worth knowing: anyone can flag an address, and dividends that address still has not claimed 24 hours later can be swept to the reserve. Swept dividends are then redistributed to active holders from the reserve.

uint256 public accSpyPerToken;                // MasterChef-style accumulator
mapping(address => uint256) debt;

function collect() external {
    uint256 owed = balanceOf[msg.sender] * accSpyPerToken / 1e18 - debt[msg.sender];
    debt[msg.sender] = balanceOf[msg.sender] * accSpyPerToken / 1e18;
    SPYON.transfer(msg.sender, owed);
    emit Collected(msg.sender, owed);
}

function flag(address[] calldata who) external;    // starts a 24 h clock per address
function sweep(address[] calldata who) external;   // unclaimed after 24 h → reserve

Stonkers

Stonkers are 666 NFTs that live off the raids. Token holders earn from trading; Stonkers holders earn from what raids take and from the collection's own royalties. Mint is in ETH, 0.00666 per Stonker, six per wallet at most.

Two income streams

Rarity and weight

Both streams are split by weight, not per head. Each class holds roughly the same share of the pool as a whole; what changes is how many hands it is split between. One Pepe earns as much as ten Humans.

Mint and reveal

Every Stonker mints unrevealed and shows only a tie. The tie colour tells you the class; the rest of the picture stays hidden. The class is drawn at mint from a fixed bag of all 666 using a future block hash, so nobody can pick an id and snipe a rarity; traits stay hidden until reveal. Reveal happens 24 hours after sellout. If it has not happened 30 hours after sellout, anyone can force it on chain.

↓Humanred tie

↓Wojakgreen tie

↓Catblack tie

↓Shibagrey tie

↓Hippoyellow tie

↓Pepeblue tie

Top row is what you hold before reveal, bottom row is what it becomes.

The art

Every Stonker is pixel art drawn at 48×48 and delivered at 960×960, scaled by whole pixels with no smoothing, so it stays sharp on marketplaces, in wallets and in link previews. On top of the six classes the collection has 36 traits, and six one-of-ones — one in each class. Traits and one-of-ones are cosmetic: what a Stonker earns depends on its class weight and nothing else.

Timeline

Until sellout the Stonkers pool fills but pays nobody. Everything accrued in that time is distributed 24 hours after the last Stonker is minted, together with the reveal. From then on raid income accrues continuously and royalty income is distributed once every 24 hours. Claims stay locked until that first distribution.

The claim belongs to the NFT

Earnings are booked against the token id, not the wallet. Sell a Stonker and everything it has accrued but not claimed goes with it — the buyer claims it.

uint256 public accPerWeight;                         // same accumulator as dividends, weighted by rarity
mapping(uint256 => uint256) public debtOf;           // keyed by token id, not by owner

function claim(uint256[] calldata ids) external {
    require(block.timestamp >= soldOutAt + 24 hours, "locked");
    for (uint256 i; i < ids.length; i++) {
        require(ownerOf(ids[i]) == msg.sender);
        uint256 w    = weightOf(ids[i]);                 // 1, 2, 5 or 10
        uint256 owed = w * accPerWeight / 1e18 - debtOf[ids[i]];
        debtOf[ids[i]] = w * accPerWeight / 1e18;
        STONKTOWER.transfer(msg.sender, owed);
    }
}

Launch

100% of supply goes to the pool and liquidity is locked with no withdraw path. There is no max wallet and no buy limit at any point. For the first 50 blocks raids are switched off, so the opening minutes cannot be farmed. No team allocation, no presale, no vesting schedule to watch.

Contracts

$STONKTOWER contract: TBA. Stonkers contract: TBA. Addresses are published at launch. Verify them on Etherscan before trading or minting — the only official source is the link in the header.