Contract

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489

// SPDX-License-Identifier: MIT
pragma solidity 0.8.28;

import {IHooks} from "@uniswap/v4-core/src/interfaces/IHooks.sol";
import {IPoolManager} from "@uniswap/v4-core/src/interfaces/IPoolManager.sol";
import {Hooks} from "@uniswap/v4-core/src/libraries/Hooks.sol";
import {LPFeeLibrary} from "@uniswap/v4-core/src/libraries/LPFeeLibrary.sol";
import {FullMath} from "@uniswap/v4-core/src/libraries/FullMath.sol";
import {PoolKey} from "@uniswap/v4-core/src/types/PoolKey.sol";
import {PoolId} from "@uniswap/v4-core/src/types/PoolId.sol";
import {SwapParams} from "@uniswap/v4-core/src/types/PoolOperation.sol";
import {BalanceDelta, BalanceDeltaLibrary} from "@uniswap/v4-core/src/types/BalanceDelta.sol";
import {
    BeforeSwapDelta,
    BeforeSwapDeltaLibrary,
    toBeforeSwapDelta
} from "@uniswap/v4-core/src/types/BeforeSwapDelta.sol";

/**
 * LittleJohnHook — the v4 hook attached to every LittleJohn launch pool.
 *
 * v1 scope (hook pack v1): anti-snipe FEE DECAY + creator SELL-LOCK.
 * v1.1 (BidWall buy-support, block-delay, volatility fee) extends
 * `LaunchFeeConfig` with new fields — append only, never repurpose.
 *
 * ETH-LEG FEE (operator directive 2026-07-09, "Stack v4"): the pool's own LP
 * fee is forced to ZERO and the HOOK takes the trading fee, ALWAYS FROM THE ETH
 * LEG, in BOTH swap directions, via the canonical Uniswap v4 hook-delta
 * mechanism (return a BeforeSwapDelta / afterSwap delta + settle it with the
 * PoolManager). This is the same "take a fee from the swap and hold it as an
 * ERC-6909 claim" pattern used by production fee hooks (Flaunch / Clanker /
 * Zora coin hooks all take their cut through the hook-delta path rather than a
 * hand-rolled transfer):
 *
 * The rule is direction- AND swap-type-agnostic: ETH (currency0) is the
 * SPECIFIED currency exactly when `zeroForOne == exactInput`, and its amount is
 * then known in `beforeSwap` (|amountSpecified|); otherwise ETH is the
 * UNSPECIFIED currency and its amount is known only in `afterSwap`
 * (|delta.amount0()|). The hook takes the fee in whichever callback the ETH leg
 * is known, so ALL FOUR swap shapes pay `feeBps` of the ETH leg:
 *   - exact-input BUY  (ETH in, zeroForOne): ETH specified -> beforeSwap, fee of
 *     the ETH input; pool swaps ETH-minus-fee, trader pays the full input.
 *   - exact-input SELL (ETH out, !zeroForOne): ETH unspecified -> afterSwap, fee
 *     of the ETH output; seller receives ETH-minus-fee.
 *   - exact-output SELL (ETH out, !zeroForOne): ETH specified -> beforeSwap;
 *     the pool produces requested ETH+fee and the seller receives exactly the
 *     requested ETH, where fee=floor((requested+fee)*bps/BPS).
 *   - exact-output BUY (ETH in, zeroForOne): ETH unspecified -> afterSwap; the
 *     buyer pays pool ETH+fee with the same floor fixed-point equation.
 *
 * The ERC-6909 claim is minted STRAIGHT TO THE PER-LAUNCH LpLockerV4 (recorded
 * at registration). Minting (vs. `take`) is what makes this correct on a
 * single-sided launch pool: on a BUY the trader's ETH has not settled into the
 * PoolManager yet, so there is no real ETH to `take` — the ERC-6909 claim is a
 * deferred credit the locker redeems into real ETH on its (permissionless)
 * `collectFees`, where it is split 1/3 protocol + 2/3 creator and AUTO-PUSHED to
 * both. There is ONE fee path: hook -> locker claim -> locker distribution. The
 * hook holds no ETH and no state; the claim balance IS the accrual.
 *
 * FEE RATE is the SAME `feeAtElapsed` anti-snipe decay curve and the SAME
 * creator sell-lock as before, applied to the ETH-leg fee. `feeAtElapsed`
 * mirrors packages/contract/src/schemas.ts EXACTLY: the fee decays LINEARLY from
 * `feeStartBps` to `feeEndBps` over `feeDurationSec` from launch, then holds at
 * `feeEndBps` forever. `feeDurationSec == 0` means decay off (static
 * `feeEndBps`). Time base is block.timestamp (Arbitrum Orbit/Nitro: block.number
 * is an L1 estimate and MUST NOT be used for time windows).
 *
 * Fee is taken on EVERY swap regardless of exact-input vs exact-output
 * (operator directive 2026-07-09, exact-output fee): the platform routers, the
 * wizard, and the atomic dev-buy produce exact-input, but a UniversalRouter
 * exact-output route (or any third-party router) now pays the identical ETH-leg
 * `feeBps` too — closing the former exact-output revenue leak. Specified-ETH
 * swaps are intentionally atomic/full-fill: a price limit that only partially
 * fills them reverts rather than charging a fee against the requested amount.
 * Full-fill swaps cannot over-skim past `feeBps` or trap a holder; exact-input
 * SELL remains the ordinary always-available exit shape.
 *
 * RUG-PROOF INVARIANTS (operator directive 2026-07-09; each has a negative
 * test, see contracts/README.md "Rug-proof invariants"):
 * 1. HARD FEE CAP — `feeEndBps` (the fee that applies outside the decay
 *    window, i.e. forever) can never exceed MAX_STATIC_FEE_BPS (5%). A fee
 *    above the cap can only exist inside the bounded decay window.
 * 2. IMMUTABLE AT LAUNCH — a pool's config is registered ONCE by the factory
 *    in the launch transaction. There is no setter, no owner, no upgrade
 *    path. `register` reverts on re-registration.
 * 3. DECAY ONLY GOES DOWN — `feeStartBps >= feeEndBps` is enforced, the
 *    curve is linear, and the window is bounded at MAX_DECAY_SECONDS (1h).
 *    The fee is monotonically non-increasing in time for every config.
 * 4. SELL-LOCK IS CREATOR-ONLY — the lock can only ever restrict the single
 *    `creator` address stored at registration. There is no config shape that
 *    blocks any other holder from selling, and the lock duration is bounded.
 * 5. SYMMETRY — the fee RATE does not read the swap direction; buys and sells
 *    pay the identical `feeBps` at the same instant (the ETH-leg take is
 *    feeBps of the ETH input on a buy and feeBps of the ETH output on a sell).
 * 6. ALWAYS TRADEABLE — for a full-fill swap, the ETH-leg take is a bounded
 *    fraction (<=40% in the decay window, <=5% settled) of the ETH the trader
 *    would otherwise receive/pay. Exact-input sells remain available to every
 *    non-creator; specified-ETH partial fills intentionally revert atomically.
 *
 * Known limitation (documented, testnet v1): the sell-lock matches on
 * `tx.origin`, because `sender` in beforeSwap is the router, not the trader.
 * A creator can evade it with a second wallet; it is an anti-fat-finger /
 * anti-signal device, not custody (the same limitation every launchpad
 * sell-lock has unless tokens are vested in escrow).
 */
interface ILpLockerV4Sink {
    /// The locker exposes nothing the hook needs to call; the hook only ever
    /// MINTS ERC-6909 claims to the locker's address. This interface exists so
    /// the config's `locker` field is typed and documented, not to grant the
    /// hook any authority over the locker.
    function creator() external view returns (address);
}

contract LittleJohnHook {
    using LPFeeLibrary for uint24;
    using BalanceDeltaLibrary for BalanceDelta;

    // ---------- invariant bounds (compile-time, not config) ----------

    /// Invariant 1: the settled fee can never exceed 5%.
    uint16 public constant MAX_STATIC_FEE_BPS = 500;
    /// Operator revenue invariant: every launch settles at no less than 1%.
    uint16 public constant MIN_STATIC_FEE_BPS = 100;
    /// GLOBAL FEE CEILING (operator directive 2026-07-09): no fee may ever
    /// exceed 40% (4000 bps), not even at second zero of the anti-snipe decay
    /// window. The permanent fee cap stays MAX_STATIC_FEE_BPS (500). Matches
    /// the zod schema (packages/contract v0.13.0, feeDecay.startBps max 4000).
    uint16 public constant MAX_START_FEE_BPS = 4000;
    /// Invariant 3: the decay window can never exceed 1 hour.
    uint32 public constant MAX_DECAY_SECONDS = 3600;
    /// Invariant 4: the creator sell-lock can never exceed 30 days.
    uint32 public constant MAX_SELL_LOCK_SECONDS = 30 days;
    /// bps denominator for the ETH-leg fee take.
    uint16 internal constant BPS_DENOMINATOR = 10_000;
    /// ERC-6909 id of native ETH == currency0 == toId(address(0)) == 0. Launch
    /// pools pair against native ETH (currency0 == address(0)) on chain 4663.
    uint256 internal constant ETH_CLAIM_ID = 0;

    IPoolManager public immutable poolManager;
    /// The only address that may register configs / initialize our pools.
    address public immutable factory;

    /// Per-pool launch config. Written ONCE (invariant 2). Extended (append
    /// only) by hook pack v1.1: bidWall / blockDelay / dynamicFee fields.
    struct LaunchFeeConfig {
        address creator; // the launch creator (sell-lock target + fee-split side in the locker)
        uint40 launchedAt; // decay t=0; also the "is registered" sentinel (never 0 once set)
        uint40 sellLockUntil; // 0 = no sell-lock
        uint16 feeStartBps; // decay opening fee; == feeEndBps when decay off
        uint16 feeEndBps; // settled base fee, capped at MAX_STATIC_FEE_BPS
        uint32 feeDurationSec; // 0 = decay off
        address locker; // the per-launch LpLockerV4 the ETH-leg fee claim is minted to
    }

    mapping(PoolId => LaunchFeeConfig) internal _configs;

    event LaunchRegistered(
        PoolId indexed poolId,
        address indexed creator,
        address indexed locker,
        uint16 feeStartBps,
        uint16 feeEndBps,
        uint32 feeDurationSec,
        uint40 sellLockUntil
    );
    /// The ETH-leg fee the hook took on a swap, minted to the locker as an
    /// ERC-6909 native-ETH claim (redeemed + distributed on locker.collectFees).
    event EthFeeTaken(PoolId indexed poolId, bool indexed isBuy, uint256 ethFee, uint16 feeBps);

    error NotPoolManager();
    error PartialFillUnsupported();
    error FeeRoundsToZero();
    error OnlyFactory();
    error AlreadyRegistered();
    error NotRegistered();
    error NotDynamicFee();
    error ZeroCreator();
    error ZeroLocker();
    error FeeAboveCap(uint16 requested, uint16 cap);
    error FeeBelowFloor(uint16 requested, uint16 floor);
    error DecayGoesUp(uint16 startBps, uint16 endBps);
    error DecayTooLong(uint32 requested, uint32 max);
    error DecayWithoutWindow();
    error SellLockTooLong(uint32 requested, uint32 max);
    error CreatorSellLocked(uint40 until);

    constructor(IPoolManager poolManager_, address factory_) {
        if (address(poolManager_) == address(0) || factory_ == address(0)) revert OnlyFactory();
        poolManager = poolManager_;
        factory = factory_;
        // Fail fast if the mined address does not carry EXACTLY the flag bits
        // this hook implements: beforeInitialize + beforeSwap (+ its return
        // delta) + afterSwap (+ its return delta). The two return-delta flags
        // are what let the hook take the ETH-leg fee in each direction.
        Hooks.validateHookPermissions(IHooks(address(this)), _hookPermissions());
    }

    /// The exact flag set this hook's mined address must carry. `virtual` so
    /// the bonding hook (LittleJohnBondingHook) can extend it with its
    /// beforeAddLiquidity gate — Solidity dispatches virtual calls made from a
    /// base constructor to the most-derived override, so the constructor
    /// check above validates the REAL permission set of whichever hook is
    /// being deployed. Pure (reads nothing), so calling it before derived
    /// state is initialized is safe.
    function _hookPermissions() internal pure virtual returns (Hooks.Permissions memory) {
        return Hooks.Permissions({
            beforeInitialize: true,
            afterInitialize: false,
            beforeAddLiquidity: false,
            afterAddLiquidity: false,
            beforeRemoveLiquidity: false,
            afterRemoveLiquidity: false,
            beforeSwap: true,
            afterSwap: true,
            beforeDonate: false,
            afterDonate: false,
            beforeSwapReturnDelta: true,
            afterSwapReturnDelta: true,
            afterAddLiquidityReturnDelta: false,
            afterRemoveLiquidityReturnDelta: false
        });
    }

    // ---------- factory wiring ----------

    /**
     * Register a launch pool's immutable config. Factory-only, once-only
     * (invariant 2), called in the same transaction that initializes the
     * pool. All invariant bounds are enforced HERE, on-chain — the factory
     * validates too, but this contract does not trust its caller's checks.
     * `locker` is the per-launch LpLockerV4 the ETH-leg fee claim is minted to.
     */
    function register(
        PoolId poolId,
        address creator,
        uint16 feeStartBps,
        uint16 feeEndBps,
        uint32 feeDurationSec,
        uint32 sellLockSeconds,
        address locker
    ) external {
        if (msg.sender != factory) revert OnlyFactory();
        if (creator == address(0)) revert ZeroCreator();
        if (locker == address(0)) revert ZeroLocker();
        if (_configs[poolId].launchedAt != 0) revert AlreadyRegistered(); // invariant 2
        if (feeEndBps < MIN_STATIC_FEE_BPS) revert FeeBelowFloor(feeEndBps, MIN_STATIC_FEE_BPS);
        if (feeEndBps > MAX_STATIC_FEE_BPS) revert FeeAboveCap(feeEndBps, MAX_STATIC_FEE_BPS); // invariant 1
        if (feeStartBps > MAX_START_FEE_BPS) revert FeeAboveCap(feeStartBps, MAX_START_FEE_BPS);
        if (feeStartBps < feeEndBps) revert DecayGoesUp(feeStartBps, feeEndBps); // invariant 3
        if (feeDurationSec > MAX_DECAY_SECONDS) revert DecayTooLong(feeDurationSec, MAX_DECAY_SECONDS); // invariant 3
        if (feeDurationSec == 0 && feeStartBps != feeEndBps) revert DecayWithoutWindow();
        if (sellLockSeconds > MAX_SELL_LOCK_SECONDS) revert SellLockTooLong(sellLockSeconds, MAX_SELL_LOCK_SECONDS); // invariant 4

        uint40 nowTs = uint40(block.timestamp);
        // Build in memory then store+emit from the struct (memory field reads,
        // not 7 live stack params) to stay within stack depth without via-ir.
        LaunchFeeConfig memory cfg = LaunchFeeConfig({
            creator: creator,
            launchedAt: nowTs,
            sellLockUntil: sellLockSeconds == 0 ? 0 : nowTs + uint40(sellLockSeconds),
            feeStartBps: feeStartBps,
            feeEndBps: feeEndBps,
            feeDurationSec: feeDurationSec,
            locker: locker
        });
        _configs[poolId] = cfg;
        emit LaunchRegistered(
            poolId, cfg.creator, cfg.locker, cfg.feeStartBps, cfg.feeEndBps, cfg.feeDurationSec, cfg.sellLockUntil
        );
    }

    // ---------- v4 hook callbacks ----------

    /// Only the factory may attach this hook to a pool, the pool must be
    /// registered first (same tx), and it must carry the dynamic-fee flag.
    function beforeInitialize(address sender, PoolKey calldata key, uint160) external view returns (bytes4) {
        if (msg.sender != address(poolManager)) revert NotPoolManager();
        if (sender != factory) revert OnlyFactory();
        if (_configs[key.toId()].launchedAt == 0) revert NotRegistered();
        if (!key.fee.isDynamicFee()) revert NotDynamicFee();
        return IHooks.beforeInitialize.selector;
    }

    /**
     * BUY-side ETH-leg fee + creator sell-lock + LP-fee override to 0.
     * - LP fee: forced to 0 (override flag), so the pool itself charges nothing
     *   and 100% of the trading fee is the hook's ETH-leg take.
     * - Sell-lock: reverts sells (token in -> ETH out, i.e. !zeroForOne) whose
     *   tx.origin is the creator, inside the window (invariant 4: hardwired to
     *   the creator address; no other address can match).
     * - Fee: on an exact-input BUY the hook mints `feeBps` of the ETH INPUT to
     *   the locker as an ERC-6909 native-ETH claim and returns it as the
     *   specified delta (invariant 5 — `feeBps` is direction-agnostic). The
     *   atomic factory dev-buy pays the settled base fee, not the t=0 anti-snipe
     *   fee (Flaunch precedent; only the factory can be `sender` and it only
     *   buys). Sells take their ETH-leg fee in `afterSwap` (ETH is the output).
     */
    function beforeSwap(address sender, PoolKey calldata key, SwapParams calldata params, bytes calldata)
        external
        returns (bytes4, BeforeSwapDelta, uint24)
    {
        if (msg.sender != address(poolManager)) revert NotPoolManager();
        LaunchFeeConfig storage cfg = _configs[key.toId()];

        // sell-lock: a sell of the launch token is token->ETH, i.e. currency1
        // in, i.e. zeroForOne == false (ETH is always currency0 on 4663).
        if (
            !params.zeroForOne && cfg.sellLockUntil != 0 && block.timestamp < cfg.sellLockUntil
                && tx.origin == cfg.creator
        ) {
            revert CreatorSellLocked(cfg.sellLockUntil);
        }

        // ETH-leg fee is taken HERE whenever ETH (currency0) is the SPECIFIED
        // currency, i.e. `zeroForOne == exactInput` — that is exact-input BUYS
        // (ETH specified input) and exact-output SELLS (ETH specified output).
        // In both, the ETH leg amount is |amountSpecified|, known now. The other
        // two shapes (ETH unspecified) take the fee in afterSwap. The pool's own
        // LP fee is always forced to 0 (override), so 100% of the fee is the hook
        // take. `sender == factory` (the atomic dev-buy) still pays the settled
        // base fee, not the t=0 anti-snipe fee (see _feeBpsFor).
        bool exactInput = params.amountSpecified < 0;
        bool ethIsSpecified = params.zeroForOne == exactInput;
        uint256 ethLeg = exactInput ? uint256(-params.amountSpecified) : uint256(params.amountSpecified);
        BeforeSwapDelta d = ethIsSpecified
            ? _takeSpecifiedEthFee(cfg, key.toId(), sender, ethLeg, params.zeroForOne, !exactInput)
            : BeforeSwapDeltaLibrary.ZERO_DELTA;
        return (IHooks.beforeSwap.selector, d, LPFeeLibrary.OVERRIDE_FEE_FLAG);
    }

    /// Take `feeBps` of the ETH leg when ETH is the SPECIFIED currency (exact-in
    /// BUY: ETH input; exact-out SELL: ETH output). Mint an ERC-6909 native-ETH
    /// claim to the locker and return the positive specified delta. On the
    /// exact-in buy this reduces the amount the pool swaps (trader pays full
    /// input, pool swaps input-minus-fee); on the exact-out sell it raises the
    /// pool's ETH output to `ethOut + fee` and skims the fee back, so the seller
    /// receives exactly the ETH they asked for. Either way the hook's mint debit
    /// nets to zero against the specified-delta credit.
    function _takeSpecifiedEthFee(
        LaunchFeeConfig storage cfg,
        PoolId poolId,
        address sender,
        uint256 ethLeg,
        bool isBuy,
        bool grossUp
    ) private returns (BeforeSwapDelta) {
        uint16 bps = _feeBpsFor(cfg, sender);
        uint256 fee = _feeAmount(ethLeg, bps, grossUp);
        if (bps > 0 && fee == 0) revert FeeRoundsToZero();
        poolManager.mint(cfg.locker, ETH_CLAIM_ID, fee);
        emit EthFeeTaken(poolId, isBuy, fee, bps);
        return toBeforeSwapDelta(int128(int256(fee)), int128(0));
    }

    /**
     * ETH-leg fee for the swaps where ETH (currency0) is the UNSPECIFIED
     * currency, i.e. `zeroForOne != exactInput` — exact-input SELL (ETH out) and
     * exact-output BUY (ETH in). The ETH leg is only known now, as
     * |delta.amount0()| (positive when the pool paid ETH out on a sell, negative
     * when it pulled ETH in on an exact-output buy). The hook mints `feeBps` of
     * it to the locker and returns the positive unspecified afterSwap delta, so
     * the seller receives (grossEthOut - fee) and the exact-output buyer pays
     * (grossEthIn + fee). The ETH-specified shapes already took their fee in
     * beforeSwap, so they return 0 here.
     */
    /// `public virtual` (not `external`): the Bonding stack's derived hook
    /// (LittleJohnBondingHook) super-calls this then latches its graduation
    /// milestone. Visibility-only change — logic and selector are identical,
    /// and already-deployed instances are bytecode-frozen on chain regardless.
    function afterSwap(
        address sender,
        PoolKey calldata key,
        SwapParams calldata params,
        BalanceDelta delta,
        bytes calldata
    ) public virtual returns (bytes4, int128) {
        if (msg.sender != address(poolManager)) revert NotPoolManager();
        bool exactInput = params.amountSpecified < 0;
        bool ethIsSpecified = params.zeroForOne == exactInput;
        int128 fee = int128(0);
        if (ethIsSpecified) {
            _enforceSpecifiedFullFill(_configs[key.toId()], sender, params, delta);
        } else {
            int128 a0 = delta.amount0();
            if (a0 != 0) {
                fee = _takeUnspecifiedEthFee(
                    _configs[key.toId()], key.toId(), sender, _abs(a0), params.zeroForOne, !exactInput
                );
            }
        }
        return (IHooks.afterSwap.selector, fee);
    }

    /// Take `feeBps` of the ETH leg when ETH is the UNSPECIFIED currency: mint an
    /// ERC-6909 native-ETH claim to the locker and return the positive
    /// unspecified afterSwap delta. On a sell that reduces the seller's ETH
    /// receipt by `fee`; on an exact-output buy it increases the buyer's ETH
    /// payment by `fee`. The mint debit nets to zero against the returned credit.
    function _takeUnspecifiedEthFee(
        LaunchFeeConfig storage cfg,
        PoolId poolId,
        address sender,
        uint256 ethLeg,
        bool isBuy,
        bool grossUp
    ) private returns (int128) {
        uint16 bps = _feeBpsFor(cfg, sender);
        uint256 fee = _feeAmount(ethLeg, bps, grossUp);
        if (bps > 0 && fee == 0) revert FeeRoundsToZero();
        poolManager.mint(cfg.locker, ETH_CLAIM_ID, fee);
        emit EthFeeTaken(poolId, isBuy, fee, bps);
        return int128(int256(fee));
    }

    function _feeAmount(uint256 ethLeg, uint16 bps, bool grossUp) private pure returns (uint256) {
        if (bps == 0) return 0;
        // Exact-output gross-up is the floor solution to
        // fee = floor((netEth + fee) * bps / BPS_DENOMINATOR).
        return
            grossUp
                ? FullMath.mulDiv(ethLeg, bps, BPS_DENOMINATOR - bps)
                : FullMath.mulDiv(ethLeg, bps, BPS_DENOMINATOR);
    }

    function _abs(int128 value) private pure returns (uint256) {
        int256 widened = int256(value);
        return uint256(widened < 0 ? -widened : widened);
    }

    function _enforceSpecifiedFullFill(
        LaunchFeeConfig storage cfg,
        address sender,
        SwapParams calldata params,
        BalanceDelta delta
    ) private view {
        bool exactInput = params.amountSpecified < 0;
        uint256 ethLeg = exactInput ? uint256(-params.amountSpecified) : uint256(params.amountSpecified);
        uint256 specifiedFee = _feeAmount(ethLeg, _feeBpsFor(cfg, sender), !exactInput);
        int256 expectedCoreEth = exactInput ? -int256(ethLeg - specifiedFee) : int256(ethLeg + specifiedFee);
        if (int256(delta.amount0()) != expectedCoreEth) revert PartialFillUnsupported();
    }

    // ---------- fee curve (public so UI/indexer/tests share one source) ----------

    /// The ETH-leg fee bps for a swap: the atomic factory dev-buy pays the
    /// settled base fee; everyone else pays the live decay fee.
    function _feeBpsFor(LaunchFeeConfig storage cfg, address sender) internal view returns (uint16) {
        return sender == factory
            ? cfg.feeEndBps
            : feeBpsAtElapsed(cfg.feeStartBps, cfg.feeEndBps, cfg.feeDurationSec, block.timestamp - cfg.launchedAt);
    }

    /**
     * Solidity mirror of `feeAtElapsed` (packages/contract/src/schemas.ts):
     *   if (elapsedSec <= 0) return startBps;
     *   if (elapsedSec >= durationSec) return endBps;
     *   return Math.round(startBps + (endBps - startBps) * (elapsed / duration));
     * JS Math.round(start - x) with integer `start` equals start - roundHalfDown(x)
     * (Math.round rounds half toward +inf; the subtraction flips it), so the
     * integer form is roundHalfDown(delta * elapsed / duration) with
     * roundHalfDown(n/d) = (2n + d - 1) / (2d).
     * durationSec == 0 means decay off -> always endBps (== startBps, enforced
     * at register). Monotonically non-increasing for every valid config
     * (invariant 3): delta >= 0 and reduction grows with elapsed.
     */
    function feeBpsAtElapsed(uint16 startBps, uint16 endBps, uint32 durationSec, uint256 elapsedSec)
        public
        pure
        returns (uint16)
    {
        if (durationSec == 0 || elapsedSec >= durationSec) return endBps;
        if (elapsedSec == 0) return startBps;
        uint256 delta = uint256(startBps) - uint256(endBps);
        uint256 reduction = (2 * delta * elapsedSec + durationSec - 1) / (2 * uint256(durationSec));
        return uint16(uint256(startBps) - reduction);
    }

    /// Live fee (bps) for a launch pool right now — the UI's snipe clock and the
    /// exact rate the ETH-leg take uses for both buys and sells (invariant 5).
    function currentFeeBps(PoolId poolId) external view returns (uint16) {
        LaunchFeeConfig storage cfg = _configs[poolId];
        if (cfg.launchedAt == 0) revert NotRegistered();
        return feeBpsAtElapsed(cfg.feeStartBps, cfg.feeEndBps, cfg.feeDurationSec, block.timestamp - cfg.launchedAt);
    }

    function configOf(PoolId poolId) external view returns (LaunchFeeConfig memory) {
        return _configs[poolId];
    }
}