A passive throne gameThe Self-Sealing Flywheel$KOTH is the first AMM-native game whose only mechanic is a competitive auction over passive yield — and the protocol burns its own supply every time a king walks away.
What's new
Memecoins ask the holder to hope. Yield-bearing tokens demand the holder to stake. $KOTH does neither. The buy transaction itself is the entire claim: a single swap above the decayed-record × 1.03 threshold seats the buyer on the throne, and from that block forward 2 % of every subsequent swap — buy or sell — flows to their wallet, untouched.
No staking contract, no emissions schedule, no vote. The yield is a side-effect of the pool itself, paid in ETH, settled by the AMM every time someone touches the pair. Price discovery and the auction over the cashflow are the same trade.
Utility — three loops in one
The protocol stitches three economic loops together. None of them require a UI or a multisig vote.
Holding the crown earns 2 % ETH on every swap. Bigger volume, bigger yield. The king has every reason to advertise the token because their inbox grows with the pool's volume.
Anyone can dethrone the king by paying ≥ record × 1.03. The record decays linearly to zero over 3,600 blocks, so the ticket gets cheaper every block. There is always a future buyer for whom the throne becomes affordable.
Every swap burns 1 % of the KOTH side. Every unclaimed reign gets its ETH coffers spent on KOTH and burned. Supply only ever moves down. See Buyback & Burn below.
Why only v4 hooks make this possible
The whole machine is wired into the AMM, not bolted on top. That is not a stylistic choice — it is the only way the math closes.
beforeSwap / afterSwap hooks let the contract observe every trade against the pair and take a delta from the swap atomically. Pre-v4 (v2, v3, every fork) there is no callback at the pool level — you can only tax at the token's transfer() level, which traders work around by routing through wrappers.
function beforeSwap(address sender, PoolKey calldata key, SwapParams calldata p, bytes calldata)
external returns (bytes4, BeforeSwapDelta, uint24)
{
uint256 amt = uint256(-p.amountSpecified);
uint256 fee;
if (p.zeroForOne) { // ETH -> KOTH (buy)
fee = amt * 200 / 10_000; // 2% to the king
poolManager.take(key.currency0, address(this), fee);
kingBalances[currentKing] += fee;
} else { // KOTH -> ETH (sell)
fee = amt * 100 / 10_000; // 1% burned
poolManager.take(key.currency1, address(this), fee);
koth.burnFromHook(fee);
}
BeforeSwapDelta delta = toBeforeSwapDelta(int128(int256(fee)), 0);
return (IHooks.beforeSwap.selector, delta, 0);
}BEFORE_SWAP_RETURNS_DELTA and AFTER_SWAP_RETURNS_DELTA (hook address bits 0xCC) let us settle fees in the swap's own currency without a separate transfer — so the king's 2 % and the burn's 1 % cost no extra gas and no extra approvals.
tx.origin coronation. Because the hook runs inside the PoolManager's locked context, every swap — direct, through 1inch, through CoW, through any aggregator that hasn't even shipped yet — is visible to the hook. The new king is whoever signed the transaction, even if the swap went through ten wrappers in between. There is no DEX you have to integrate against; the integration is the AMM.
Internal unlock. The forfeit / buyback path uses the same poolManager.unlock() primitive to buy KOTH out of the pool and burn it — without leaving the hook, without slippage attacks, without a keeper bot that can front-run. The mechanism is part of the pool.
In short: $KOTH could not exist on Solana, on a Curve-style AMM, on Uniswap v2, or on a wrapper token. It needs the hooked AMM boundary that v4 introduces, and it needs the exact return-delta flags that v4 added to that boundary.
Self-contained buy pressure
Most tokens ask why would someone buy this. $KOTH builds the answer into the contract. Four mechanisms apply on every swap:
Throne competition. The record threshold (record × 1.03) is the smallest buy that lays claim. Every coronation is, by definition, a price-discovery event larger than the previous record — until decay re-opens the window.
Yield arbitrage. The 2 % cashflow scales with volume. As volume grows, the implied yield on a coronation grows, and the implied fair price of the throne follows it. There is a rational price for the crown at any volume level.
Programmatic buyback. Every unclaimed reign (no claim within 12 h after dethrone) becomes swap-and-burn fuel. The hook itself buys KOTH out of the pool with the coffers and incinerates the result. This is actual on-chain buy pressure, not a roadmap promise.
Per-swap burn. 1 % of the KOTH side of every trade is permanently destroyed. The total supply ratchets down forever, with no admin switch to disable it.
Buyback & Burn
When a king is dethroned, their accumulated 2 % stream is locked in a coffer. They have 12 hours to claim it. If they do not, the protocol acts on its own — without an admin call, without a multisig, without a vote.
3 % of the coffer is paid to whichever wallet calls forfeit() — a keeper-economics primitive so the buyback never gets stuck.
97 % is spent inside the same transaction on KOTH from the pool. The KOTH the hook receives goes straight to burnFromHook() and is destroyed.
The pool sees a real buy, the supply shrinks, and every remaining holder ends up with a marginally larger claim on future swaps.
What we are not
We are not a yield farm. There is no LP token, no staking, no auto-compounding vault on top. The yield is the swap fee, paid in ETH, to one wallet, until that wallet is replaced.
We are not a governance token. There is nothing to vote on. The parameters (3 %, 2 %, 1 %, 12 h, 3,600 blocks) are immutable constants compiled into the hook bytecode.
We are not a memecoin. The throne is the entire utility, and the throne is measurable: at any block you can compute the king's running yield, the record-decay, and the next coronation cost. Holding KOTH is exposure to the realm's volume, paid in ETH.