The contracts and the math.

_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  // the staircase: what the steps sold is split before the solve  _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  // the vault's tokens join the step above the price, at ≥ 2× cost  at = _deployAsk(key); _deployBid(key)  emit Ratcheted(floorTick, at, vaultEth, inventoryTokens, bounty)

Each teardown and redeploy loses a wei or two to v4’s rounding, which runs against the liquidity provider. The no-op guard at the top stops a spammer turning idle ratchets into a slow drain. For the same reason, the bounty is paid from unpaidSkim only. The bounty and the nudge’s reserve both leave before the solve. So the bid always holds at least the Q its floor was solved on. If they left after, the bid could land up to MAX_BOUNTY short of the floor it was solved for. The closing clamp holds the published floor where the bid can stand: one spacing above where the market ended, plus W. So a third party parked in the gap delays the rise, rather than leaving a bid under the floor. The clamp never lowers the standing floor.

uint256 public constant PLATFORM_BPS = 250;
address platformVault;       // per pool, written once at registerPool (see 07, 08, 09)
bytes32 platformPoolId;      // LODE's pool, when platformVault is the hook itself
uint256 platformPaidEth;     // lifetime forwarded (launched pools)
uint256 platformReceivedEth; // lifetime received  (LODE'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;
    if (platformVault == address(this)) {      // a native pool on a set with a LODE pool; no EVM chain has one
        PoolState storage target = pools[platformPoolId];
        if (target.quoteToken != quoteToken) revert BadQuoteToken();
        FloorPoolVault(custodyVault).payQuote(target.custodyVault, cut);
        target.vaultEth += cut;
        target.platformReceivedEth += cut;
        target.needsRatchet = true;
    } else {                                   // the treasury: any stock pool, or an ETH pool with no LODE pool here
        FloorPoolVault(custodyVault).forwardQuote(platformVault, cut, false);
    }
    emit PlatformCut(poolId, cut);
    return amount - cut;
}

Every inflow passes through _intake before the vault books it:

The bid’s own ETH returning in _teardownBid is the vault’s money coming home, so it never passes through _intake. The code above is the EVM hook. No EVM chain has a $LODE pool, so there the launch’s vault pays the treasury’s intake. Only a registered pool’s own vault may call it, and it credits balanceOf[quote]. Every vault payment holds a transient reentrancy lock.

On Ethereum nothing moves to $LODE during a trade. The program books a ETH launch’s cut on the launch’s own pool. A permissionless keeper sweeps booked cuts into $LODE’s pool, and until $LODE graduates they stay where they were booked.

The skim column is the floor skim alone. The two all in columns are what the trader pays, which is why Bluechip’s 2% skim reads 3.492%. Skim, creator fee, holder tax and the LODE Platform fee (today’s 0.25% pool rate) are four percentages of the same ETH leg, so they are summed. The pool’s 0.25% LP fee is then charged on what is left, so the two compose multiplicatively. Buys slide to 0% skim at the bid. Sells climb to 1.5× their far rate on Cook, Bluechip, Moonshot and $LODE. A Custom launch picks its own multiple, 1× to 5×. So the at-the-bid pair is asymmetric in every mode. Each pool pays the LODE Platform fee its launch was created with. At the 0.5% cap every all-in figure is about 0.25 points higher, and at 0 about 0.25 points lower.

Every preset’s far skim is 2%, so the presets differ only by their creator fee. Far from the bid, $LODE costs the same as Bluechip and more than Cook or Moonshot. On a buy at the bid it costs the same as Moonshot, and on a sell into the bid it costs more than every preset. Moonshot is the cheapest preset at both ends. 2.5 of $LODE’s 3.25 points are floor skim, booked under the token.

$LODE’s floor grows with the platform’s ETH volume on its chain: F_LODE = (Q_LODE + Σ 0.025 · inflows_i) / S_LODE, summed over every ETH pool i whose cut lands there. Nothing can withdraw it from there.

At the default sale rate, a $1,000 buy costs $1,010. Selling those tokens returns $990, because the sell pays the fee too and the buy’s fee is kept.

uint256 public constant MAX_CREATOR_BPS = 500;     // 5% each way, hard cap
uint256 creatorSlotCount;                          // 1–5 recipients, written once at registration
uint256 creatorPendingMask;                        // bit i set while slot i is a handle not yet claimed
uint256 creatorBuyBps;
uint256 creatorSellBps;
uint256 creatorFeesOwed;                           // accrued, unpaid, every slot together
uint256 creatorFeesPaid;                           // lifetime paid out, every slot together
Payee[5] creatorSlots;                             // each slot: wallet, share in bps, paid so far

registerPool(key, config, launch, referrer2, referrer3, creatorSlots)
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 $LODE cut
cfee = ethLeg · creatorBps(dir) / 10_000           // to the fee recipients, no $LODE cut
tfee = ethLeg · teamFeeBps / 10_000                // to the team at the pool's own rate, owed on the pool, no $LODE cut
poolManager.take(ETH, custodyVault, fee + cfee + tfee)
vaultEth += _intake(fee); creatorFeesOwed += cfee; teamFeesOwed += tfee
return delta(fee + cfee + tfee)

function claimCreatorFees(uint8 slot) external returns (uint256 paid) {
    Payee storage p = creatorSlots[slot];          // RecipientPendingClaim while the slot waits on its handle
    uint256 lifetime = creatorFeesPaid + creatorFeesOwed;
    paid = min(lifetime · p.bps / 10_000 − p.paid, creatorFeesOwed);
    creatorFeesOwed −= paid; creatorFeesPaid += paid; p.paid += paid;
    bool ok = _payQuote(p.wallet, paid);           // out of the pool's vault, only ever to that slot's wallet
    if (!ok) revert CreatorTransferFailed();
}

The hook takes the creator fee in the same take as the skim and returns both in the same hook delta. A swap therefore pays five things: the LP fee (0.25%), the floor skim (0–15%, ramped, to the vault), the creator fee (flat, ≤ 5%), the holder tax (flat, ≤ 10%) and the LODE Platform fee (0.25% by default, ≤ 0.5%).

The creator fee is not a vault inflow. It never passes through _intake, so $LODE takes no cut of it. 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 plus every fee it owes: to the fee recipients, the holders, the referrers and the team. Its ETH balance covers them all after every completed operation.

Each slot earns its share of everything the pool has ever booked for the creator, rounded down. A claim pays the slot what it has earned less what it was already paid. The rounding leaves at most a few wei per pool in the vault.

A slot is claimed with execute(poolId, claimCreatorFees(slot)) on the hook. Anyone may send that call, and the ETH goes only to that slot’s wallet.

The shares are of the referral share, not of the trade. On a launch with three referrers, a $100 creator fee sends $90 to the fee recipients, $9 to tier 1, $0.90 to tier 2 and $0.10 to tier 3.

library FloorModes {
    enum Mode { 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 has the same shape in every mode. Buys slide to 0% at the floor. Sells climb to 1.5× the far rate on a preset. On Custom the launcher picks the multiple, 1× to 5×. Only the skim ramps, and no rate can change after launch (see 03). Custom is the empty preset, so the hook’s own caps are its only limits. The hook caps the far skim at 10% (MAX_SKIM_FAR_BPS) and the creator fee at 5% (MAX_CREATOR_BPS). It caps the holder tax at 10% (MAX_HOLDER_BPS).

The launchpad’s presets

The launchpad offers three fixed presets, Cook, Bluechip and Moonshot, beside Custom. Each sells 20% of supply in the sale, so it raises 20% of its graduation market cap. Each keeps 10% as the protocol-owned position and sells 69% on the staircase, with 1% as an open tail (see 04).

Measured · $LODE cut on, ETH at $2,400

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

function _takeFees(key, ethLeg, zeroForOne) internal returns (uint256 total) {
    fee  = ethLeg · skimBps / 10_000            // vault, after the $LODE cut
    cfee = ethLeg · creatorBps / 10_000         // fee recipients, accrued (10% owed to a referrer)
    hfee = ethLeg · holderBps / 10_000          // holders, booked now, paid on claim
    tfee = ethLeg · teamFeeBps / 10_000         // LODE Platform fee at the pool's own rate, owed to the team (teamFeesOwed)
    poolManager.take(ETH, custodyVault, fee + cfee + hfee + tfee)
    …; holderOwedEth += hfee; IFloorHolderRewards(holderRewards).accrue(poolId, hfee);
}

// FloorHolderRewards — one per chain, behind a proxy; books only, holds no money
rewardPerShareE36[token] += amount · 1e36 / eligibleSupply   // on every accrue (1e36, not 1e18 — see the note)
onTransfer(from, to, amount):                            // called by the token, pre-transfer
    settle(from): owed += shares·rps/1e36 − debt; shares −= amount; debt = shares·rps/1e36
    settle(to):   same, shares += amount
claimable(token, who) = owed[who] + shares[who]·rps/1e36 − debt[who]
claim(token): settle(msg.sender); paid = owed; owed = 0; hook.execute(poolId, releaseHolderRewards(msg.sender, paid))

Never earns · fixed when the launch registers

Only an approved factory can register a launch, and the book checks it against the pool’s own state on the hook. An accrue made while nobody holds yet is parked in unallocated and folded into the next one. The hook books the tax on a buy in beforeSwap, before the buyer’s tokens arrive, so a buyer never pays themselves. A wallet whose balance predates binding, such as the deployer’s supply, is mirrored on its first outgoing transfer.

The book holds no money. Each launch’s holder tax waits in that launch’s own FloorPoolVault, counted as holderOwedEth. The engine’s releaseHolderRewards pays each claim. Only the pool’s own book can reach it, through hook.execute, and it refuses to pay more than that pool has accrued. A contract that holds tokens and never claims keeps its share, and nobody else can take it. On Ethereum the same tally is floor_holders, a Token-2022 transfer hook on new launches with a holder tax. It counts only the wallets that have started earning.

The accumulator is rewardPerShareE36, scaled by 1e36 so that a pool can carry a quote of any decimals. At a 1e18 scale, _deposit would floor total · ACC / eligibleSupply. Any deposit under eligibleSupply / 1e18 raw units would then credit nobody and be stranded for good. On an ETH quote with 30% sold, that threshold is 3e8 wei, which is invisible. On a 6-decimal quote the same 3e8 raw units is 300, and a holder tax on a small swap is well under it. With eligibleSupply ≤ 1e27 < 1e36, the remainder per deposit is under one raw unit. The multiplications go through FullMath.mulDiv and round down. There is no per-launch contract: every launch’s book is a slot in the chain’s single FloorHolderRewards (see 01, row 07).

Over five buy-sell rounds with a 2% / 2% holder tax and a 1% / 1% creator fee, $1,415 was deposited for holders. The first five wallets claimed $766, and the rest stayed claimable.

struct Config {
  uint256 saleTokens;      // sold in tranches
  uint256 polTokens;       // protocol-owned, token-only, open → ∞ (the tail)
  uint256 vaultTokens;     // the staircase's tokens
  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
_buy(gross)     = walk(gross · 10_000 / (10_000 + teamFeeBps)); fee = spent · teamFeeBps / 10_000   // the fee rides on top; contributed and raised count spent only
_sell(tokens)   = contributed · tokens / allocation   // your own average price; raised falls by this
sellBack pays   = _sell(tokens) − _sell(tokens) · teamFeeBps / 10_000   // less the sale's LODE Platform fee (1%) → teamOwed
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

Reference launch config

Every payee is paid its share of three things: the team’s 80% of what the team steps sell for, the team steps’ unsold tokens after the lock, and the vested wallet part.

Each payee earns its share of everything the team has been owed, rounded down. A claim pays one payee what it has earned less what it was already paid. The rounding leaves at most a few raw units in the vault.