The contracts, the math, the tests.

_ratchet(beneficiary):  // no-op guard against rounding drains (no lift, so no "gap" clause)  if !needsRatchet && unpaidSkim == 0 && vaultEth < MIN_BID_ETH:    bidCanRise = bidLiquidity > 0 && floorTick − W < bidLower               && ceilToSpacing(cur + 1) < bidLower    if !bidCanRise: return  needsRatchet = false; floor0 = floorTick  _redeemLiftClaims()          // the in-swap re-place's ERC-6909 claims come home  _sweepSeedFees(key)          // zero-delta modifyLiquidity on SEED_SALT  _teardownLadder(key)         // ETH → vault + unpaidSkim + ladderProceedsEth  _teardownBid(key)            // tokens → inventory at cost  _teardownAsk(key)            // ETH → vault; fee income vs sold accounting  // everything that leaves before the bid is placed leaves BEFORE the solve  bounty = min(unpaidSkim · BOUNTY_BPS / 10_000, MAX_BOUNTY, vaultEth)  unpaidSkim = 0; pay beneficiary (failure re-credits vaultEth)  reserve = min(vaultEth, MIN_BID_ETH)        // the nudge's dust, held out of Q  for i in 0..2:                              // solve, then the POL follows the floor    if vaultEth <= reserve || circulatingSupply() == 0: break    candidate = _publish(_solveFloorTick(vaultEth − reserve))   // dear edge + W    if candidate < floorTick: floorTick = candidate     // ratchet guard    else if i != 0: break    if !_raisePol(): break  _nudge(key, reserve)         // up to the dear edge; free across an empty gap  stand = ceilToSpacing(cur + 1 + W)          // the closing clamp  if floorTick < stand: floorTick = min(stand, floor0)   // withholds a rise, never lowers  _deployLadder(key); at = _deployAsk(key); _deployBid(key)  emit Ratcheted(floorTick, at, vaultEth, inventoryTokens, bounty)

The guard matters because each teardown/redeploy cycle loses a wei or two to v4's LP-unfavourable rounding; without it a spammer could turn idle ratchets into a slow drain (test_spammingRatchetCannotDrainBacking). The bounty is paid from unpaidSkim only, for the same reason (test_ratchetPaysBountyOutOfNewSkimOnly) — and it is paid BEFORE the solve, as is the nudge’s reserve, so the bid always holds at least the Q its floor was solved on; paid after, a bid landed up to MAX_BOUNTY short of the floor it was solved for. The closing clamp holds the published floor at a band the bid can actually stand in — one spacing above where the market ended, plus W — so a third party parked in the gap DELAYS the rise instead of leaving a bid under the floor; the standing floor is never lowered (SingletonRootFix.t.sol test_f).

uint256 public constant PLATFORM_BPS = 250;
address platformVault;       // per pool, written once at registerPool (see 07, 08, 09)
uint256 platformPaidEth;     // lifetime forwarded (launched pools)
uint256 platformReceivedEth; // lifetime received  (FLOOR's own pool)

function _intake(uint256 amount) internal returns (uint256 kept) {
    if (platformVault == address(0) || amount == 0) return amount;
    uint256 cut = (amount * PLATFORM_BPS) / 10_000;
    if (cut == 0) return amount;
    platformPaidEth += cut;
    FloorPoolVault(custodyVault).forwardQuote(platformVault, cut, false);
    emit PlatformCut(poolId, cut);
    return amount - cut;
}

function intake() external payable {        // FLOOR's pool, via execute(poolId, intake())
    vaultEth += msg.value;
    platformReceivedEth += msg.value;
    needsRatchet = true;
    emit PlatformIntake(poolId, msg.sender, msg.value);
}

Every inflow passes through _intake before the vault books it: the raise in seedFloor(), the skim in both _beforeSwap and _afterSwap (unpaidSkim and the bounty base are the kept 97.5%), ladder proceeds in _teardownLadder, ask proceeds in _teardownAsk, and ETH fees in _sweepSeedFees. The bid’s own ETH returning in _teardownBid is the vault’s money coming home, not an inflow, and never passes through it. The forward pays the cut out of the launch’s own vault into the SingletonPlatformVault, which calls execute(poolId, intake()) for the FLOOR pool; the receiving side only increments that pool’s storage, and every vault payment holds a transient reentrancy lock.

⚠ The skim column is the floor skim alone; the two all in columns are what the trader actually pays, which is why Bluechip’s 5% skim reads 5.736% — skim, creator fee and holder tax are three percentages of the same ETH leg and are summed, then the pool’s 0.25% LP fee is charged on what is left, composing multiplicatively. Buys slide to 0% skim at the bid and sells climb to 10%, so the at-the-bid pair is asymmetric in every mode. $FLOOR pairs Meme’s far rate with Bluechip’s at-the-bid rate: it is not the cheapest of the four, and Degen is cheaper far from the floor. What differs is where the money goes — 2.5 of $FLOOR’s 3.0 points are floor skim against Meme’s 2.0, so at the same total cost more of it is booked under the token. The 2.5% platform cut is a split of skim already paid and never appears in a quote.

FLOOR’s floor is a function of the whole platform’s volume: F_FLOOR = (Q_FLOOR + Σ 0.025 · inflows_i) / S_FLOOR over every launched pool i, and nothing can withdraw it from there either.

uint256 public constant MAX_CREATOR_BPS = 100;     // 1% each way, hard cap
address creator;                                   // address(0) with no pending handle disables the fee
uint256 creatorBuyBps;
uint256 creatorSellBps;
uint256 creatorFeesOwed;                           // accrued, unpaid
uint256 creatorFeesPaid;                           // lifetime paid out

registerPool(key, Config memory c, launch, platformPool)
initialize(c, launch)                              // BadRange if a rate > cap, or a rate with no recipient

// _beforeSwap / _afterSwap, per swap (currency0 = ETH, zeroForOne = buy):
fee  = ethLeg · skimBps(dir) / 10_000              // to the vault, after the platform cut
cfee = ethLeg · creatorBps(dir) / 10_000           // to the creator, no platform cut
poolManager.take(ETH, custodyVault, fee + cfee)
vaultEth += _intake(fee); creatorFeesOwed += cfee
return delta(fee + cfee)

function claimCreatorFees() external returns (uint256 paid) {
    paid = creatorFeesOwed; creatorFeesOwed = 0; creatorFeesPaid += paid;
    bool ok = _payQuote(creator, paid);            // out of the pool's vault, only ever to `creator`
    if (!ok) revert CreatorTransferFailed();
}

The creator fee is taken in the same take as the skim and returned in the same hook delta, so a swap pays LP fee (0.25%) + skim (0–10%, ramped, to the vault) + creator fee (flat, ≤ 1%) + holder tax (flat, ≤ 2%). It is not a vault inflow: it never passes through _intake, so the platform takes no cut of it, and it is never counted in vaultEth, unpaidSkim or the bounty base, so it never moves the floor. The launch’s FloorPoolVault therefore holds idle vault ETH + creatorFeesOwed, and its ETH balance must cover both after every completed operation (test/VaultIsolation.t.sol). A wallet claims with execute(poolId, claimCreatorFees()) on the hook; anyone may send it, and the ETH lands only with creator.

library FloorModes {
    enum Mode { Degen, Meme, Bluechip, Custom }
    struct Preset { uint256 graduationMcapUsd; uint256 creatorBps; uint256 skimBuyFarBps; uint256 skimSellFarBps; }
    function preset(Mode) internal pure returns (Preset memory);
    function hookConfig(Mode, uint256 liftMaxBps, address platformVault, address creator)
        internal pure returns (FloorHookStorage.Config memory);   // liftMaxBps: still passed and range-checked, read by no engine path
    function tranchePriceFor(uint256 mcapUsd, uint256 ethUsd, uint256 totalSupply)
        internal pure returns (uint256);   // mcapUsd·1e36 / (ethUsd·totalSupply)
}

The near-floor ramp does not change with the mode: by default buys slide to 0% at the floor and sells climb to 10% from whatever far rate the mode sets (the at-the-floor endpoints are per-pool state the pool’s feeAdmin may retune — 03). Custom is the empty preset — the hook’s own caps (MAX_SKIM_FAR_BPS 10%, MAX_CREATOR_BPS 1%, MAX_HOLDER_BPS 2%) are the only limits.

Measured · Modes.t.sol, platform cut on, ETH at $2,400

// hook (Config): holderRewards, holderBuyBps, holderSellBps
uint256 public constant MAX_HOLDER_BPS = 200;     // 2% each way, hard cap

function _takeFees(key, ethLeg, zeroForOne) internal returns (uint256 total) {
    fee  = ethLeg · skimBps / 10_000            // vault, after the platform cut
    cfee = ethLeg · creatorBps / 10_000         // creator, accrued
    hfee = ethLeg · holderBps / 10_000          // holders, deposited now
    poolManager.take(ETH, custodyVault, fee + cfee + hfee)
    …; FloorPoolVault(custodyVault).forwardQuote(holderRewards, hfee, true);
}

// HolderRewards
rewardPerShareE18 += deposit · 1e18 / eligibleSupply      // on every deposit
onTransfer(from, to, amount):                            // called by the token, pre-transfer
    settle(from): owed += shares·rps/1e18 − debt; shares −= amount; debt = shares·rps/1e18
    settle(to):   same, shares += amount
claimable(who) = owed[who] + shares[who]·rps/1e18 − debt[who]
claim(): settle(msg.sender); pay owed; owed = 0

Excluded, fixed in the constructor with no owner to change it: the PoolManager (holds the pool’s tokens), the launch’s FloorPoolVault (inventory), the hook, the launch contract (the sale tokens it still holds), the vesting contract (locked tokens), the OFT adapter (bridged tokens), the token, the distributor and the zero address. A deposit made while nobody holds yet is parked in unallocated and folded into the next one. The tax on a buy is deposited in beforeSwap, before the buyer’s tokens arrive, so a buyer never pays themselves. A wallet whose balance predates binding (the deployer’s supply) is mirrored on its first outgoing transfer.

Measured on the reference launch with a 2% / 2% holder tax and a 1% / 1% creator fee over five buy-sell rounds: $1,415 deposited for holders, $766 claimed by the first five wallets, the rest claimable.

struct Config {
  uint256 saleTokens;      // sold in tranches
  uint256 polTokens;       // protocol-owned, token-only, open → ∞ (the tail)
  uint256 vaultTokens;     // genesis ladder
  uint256 p0;              // ETH wei per whole token, first tranche
  uint256 p1;              // last tranche; pool opens at p1
  uint8   tranches;
  uint256 floorShareBps;   // share of the raise → seedFloor()
}
// constructor: saleTokens + polTokens + vaultTokens == totalSupply
//              p1 >= p0, p0 != 0, tranches != 0, floorShareBps <= 10_000

tranchePrice(i) = p0 + (p1 − p0) · i / (tranches − 1)
openTick()      = getTickAtSqrtPrice(sqrtPriceX96FromRatio(p1, 1e18))
canGraduate()   = funded && !graduated && sold >= saleTokens
_sell(tokens)   = contributed · tokens / allocation   // your own average price
custodyAtBuy    = token.launch() == address(this)     // probed at initialize: true on every factory sale
// the exit: token.sellBack(tokens) -> onSellBack -> _sell; FloorLaunch.sell() reverts UseSellBack
// no claim step: buy() already transferred the tokens; claim() reverts Nothing

Launch.t.sol config