hookr-sdk 0.2.1 → 1.1.0

package/dist/core/params.js

@@ -0,0 +1,1235 @@
+import { decodeAbiParameters, encodeAbiParameters } from "viem";
+import { RELEASE_CONSTANTS } from "./generated.js";
+import { checkFeeAdvisoryConfig, checkSessionSchedule, checkSessionTiers, encodeFeeAdvisoryBind, encodeSessionSchedule, feeAdvisoryMinGas, } from "./advisories.js";
+import { checkPairRootParams } from "./pair.js";
+import { ADMISSION_KIND, PHASE, checkAdmission, checkPairRootAdmission } from "./registry.js";
+import { DYNAMIC_FEE_LIQUIDITY_DIVISOR, DYNAMIC_FEE_PARAMETERS, DYNAMIC_FEE_REACH, MAX_GUARD_BLOCKS, MAX_LP_FEE_PIPS, MAX_PROTOCOL_SHARE_BPS, MAX_RULE_SHARE_FLOOR_BPS, RULES_KNOB_BOUNDS, SNIPE_CURVE, checkRulesConfig, maxSnipeDecaySeconds, withinDynamicFeeReach, effectiveShareFloor, dynamicFeeMinLiquidity, encodeRulesData, lpRewardPips, nativeLpCeiling, poolCapsFor, rulesBindCaps, rulesFeeCeilings, } from "./rules.js";
+import { address, assert, hash, ZERO, ZERO_HASH } from "./schema.js";
+const U24 = 2n ** 24n - 1n;
+const U32 = 2n ** 32n - 1n;
+const U40 = 2n ** 40n - 1n;
+const U96 = 2n ** 96n - 1n;
+const U128 = 2n ** 128n - 1n;
+const U160 = 2n ** 160n - 1n;
+const U256 = 2n ** 256n - 1n;
+const Q96 = 1n << 96n;
+const I128 = 2n ** 127n - 1n;
+const MAX_LP = MAX_LP_FEE_PIPS;
+/** v4 TickMath.MAX_TICK_SPACING. */
+const MAX_TICK_SPACING = 32_767;
+const DEFAULT_BLOCK_TIME = 12;
+/** Anti-Snipe guard length a launch starts with, in seconds. */
+const DEFAULT_GUARD_SECONDS = 600;
+function n(cfg, key) {
+    return Number(paramValue(cfg[key]));
+}
+function big(cfg, key) {
+    return paramValue(cfg[key]);
+}
+/** A knob value as an unsigned integer. Refuses fractions, negatives and malformed hex. */
+export function paramValue(v) {
+    if (typeof v === "boolean")
+        return v ? 1n : 0n;
+    if (typeof v === "bigint")
+        return v;
+    if (typeof v === "number") {
+        assert(Number.isSafeInteger(v), `Invalid knob value ${v}`);
+        return BigInt(v);
+    }
+    assert(typeof v === "string" && /^0x[\da-fA-F]+$/.test(v), `Invalid knob value ${String(v)}`);
+    return BigInt(v);
+}
+function lpReward(cfg) {
+    return lpRewardPips({
+        lpBps: n(cfg, "lpBps"),
+        protocolShareBps: n(cfg, "protocolShareBps"),
+        royaltyBps: n(cfg, "royaltyBps"),
+    });
+}
+/** First v in [lo, hi] with ok(v), for predicates that stay true once true; hi + 1 when there is none. */
+function first(lo, hi, ok) {
+    let a = lo;
+    let b = hi + 1;
+    while (a < b) {
+        const m = Math.floor((a + b) / 2);
+        if (ok(m))
+            b = m;
+        else
+            a = m + 1;
+    }
+    return a;
+}
+/** Last v in [lo, hi] with ok(v), for predicates that stay false once false; lo - 1 when there is none. */
+function last(lo, hi, ok) {
+    let a = lo - 1;
+    let b = hi;
+    while (a < b) {
+        const m = Math.ceil((a + b) / 2);
+        if (ok(m))
+            a = m;
+        else
+            b = m - 1;
+    }
+    return a;
+}
+/** base + LP Rewards within the 600,000-pip LP-fee ceiling (HookrRules._validate). */
+function lpRoom(cfg, patch) {
+    const c = { ...cfg, ...patch };
+    return n(c, "baseLpFeePips") + lpReward(c) <= MAX_LP;
+}
+const guarded = (cfg) => big(cfg, "guardEndBlock") !== 0n;
+/** The dynamic fee's span, maxFeePips less the base fee (zero without dynamic fees). */
+const span = (cfg) => Math.max(n(cfg, "maxFeePips") - n(cfg, "baseLpFeePips"), 0);
+/** The widest span HookrDynamicFee's reach bound admits at the configuration's sensitivity and protocol share. */
+const reachSpan = (cfg) => last(0, MAX_LP, (v) => withinDynamicFeeReach(v, n(cfg, "dynamicFeeSens"), n(cfg, "protocolShareBps")));
+const decaying = (cfg) => n(cfg, "snipeDecaySeconds") !== 0;
+const dynamicFeeOff = (cfg) => n(cfg, "maxFeePips") === n(cfg, "baseLpFeePips");
+const dynamicFeeOn = (cfg) => n(cfg, "dynamicFeeSens") !== 0;
+/** The default per-block guarded buy cap, in basis points of the launch's quote depth (`quoteDepth`). */
+export const DEFAULT_MAX_BUY_DEPTH_BPS = 50n;
+/**
+ * A launch member's quote depth in raw quote units: the virtual quote reserve of its liquidity at the opening price,
+ * L x 2^96 / sqrtPriceX96 when the quote is currency0 and L x sqrtPriceX96 / 2^96 when it is currency1. A buy of
+ * 0.5% of it moves the opening price about 1% while the price stays in the band. Single-sided launches seed no quote,
+ * so the seed is no measure of their depth; for a two-sided full-range seed the two are equal. Without the opening
+ * state it is the quote seed, and undefined without either.
+ */
+export function quoteDepth(ctx) {
+    const { launchLiquidity: l, launchSqrtPriceX96: p, quoteIsCurrency0: q0 } = ctx;
+    if (l !== undefined && p !== undefined && q0 !== undefined) {
+        if (p <= 0n)
+            throw new RangeError("launchSqrtPriceX96 must be positive");
+        return q0 ? (l * Q96) / p : (l * p) / Q96;
+    }
+    return ctx.quoteSeed;
+}
+/** Pool knobs of a HookrRoot launch member (PoolKey and PoolConfig). */
+const POOL = [
+    {
+        name: "baseLpFeePips",
+        type: "uint24",
+        unit: "pips",
+        where: "launch",
+        // With dynamic fees off maxFeePips equals base, so the two move together; with them the span stays within the
+        // reach bound (r31, N09).
+        min: (cfg) => n(cfg, "dynamicFeeSens") === 0 ? n(cfg, "maxFeePips") : Math.max(0, n(cfg, "maxFeePips") - reachSpan(cfg)),
+        max: (cfg) => Math.min(n(cfg, "dynamicFeeSens") === 0 ? n(cfg, "maxFeePips") : n(cfg, "maxFeePips") - 1, MAX_LP - n(cfg, "snipeTaxPips"), MAX_LP - lpReward(cfg)),
+        default: 3_000,
+        dependsOn: ["maxFeePips", "dynamicFeeSens", "snipeTaxPips", "lpBps", "royaltyBps", "protocolShareBps"],
+    },
+    // A Hookr dynamic fee pool binds at any tick spacing: the root simulates the swap, so no spacing floor applies.
+    { name: "tickSpacing", type: "int24", unit: "ticks", where: "launch", min: 1, max: MAX_TICK_SPACING, default: 60 },
+];
+/**
+ * Anti-Snipe: a launch guard with a per-block buy cap and a tax on guarded buys. The tax may decay linearly from
+ * snipeTaxPips at launch to snipeFloorPips over snipeDecaySeconds; the per-block cap grows as it falls.
+ */
+const ANTI_SNIPE = [
+    {
+        name: "guardEndBlock",
+        type: "uint40",
+        unit: "blocks",
+        where: "bind",
+        zeroIsOff: true,
+        min: (_c, ctx) => (ctx.blockNumber === undefined ? 1n : ctx.blockNumber + 1n),
+        max: (_c, ctx) => (ctx.blockNumber === undefined ? U40 : ctx.blockNumber + BigInt(MAX_GUARD_BLOCKS)),
+        default: (ctx) => ctx.blockNumber === undefined
+            ? 0n
+            : ctx.blockNumber + guardBlocksFor(DEFAULT_GUARD_SECONDS, ctx.blockTimeSeconds),
+        disclose: "While the guard lasts only the launcher adds liquidity, exact-output buys are refused and no member's principal " +
+            "can be withdrawn. It is counted in parent blocks.",
+    },
+    {
+        name: "maxBuyQuoteAmount",
+        type: "uint128",
+        unit: "raw",
+        where: "bind",
+        min: 0,
+        max: (cfg) => (guarded(cfg) ? U128 : 0n),
+        default: (ctx, cfg) => {
+            const depth = guarded(cfg) ? quoteDepth(ctx) : undefined;
+            if (depth === undefined)
+                return 0n;
+            const cap = (depth * DEFAULT_MAX_BUY_DEPTH_BPS) / 10000n;
+            return cap > U128 ? U128 : cap;
+        },
+        dependsOn: ["guardEndBlock"],
+        disclose: "Zero leaves guarded buys uncapped. Caps apply per pool, so a family's per-block cap is the sum of its members'. " +
+            "The default is 0.5% of the launch's quote depth, the buy that moves the opening price about 1%.",
+    },
+    {
+        name: "snipeTaxPips",
+        type: "uint24",
+        unit: "pips",
+        where: "bind",
+        // With a decay the launch tax sits above the floor it decays to.
+        min: (cfg) => (decaying(cfg) ? n(cfg, "snipeFloorPips") + 1 : 0),
+        max: (cfg) => (guarded(cfg) ? MAX_LP - n(cfg, "baseLpFeePips") : 0),
+        default: (_ctx, cfg) => (guarded(cfg) ? Math.min(100_000, MAX_LP - n(cfg, "baseLpFeePips")) : 0),
+        dependsOn: ["guardEndBlock", "baseLpFeePips", "snipeFloorPips", "snipeDecaySeconds"],
+    },
+    {
+        name: "snipeFloorPips",
+        type: "uint24",
+        unit: "pips",
+        where: "bind",
+        min: 0,
+        max: (cfg) => (decaying(cfg) ? n(cfg, "snipeTaxPips") - 1 : 0),
+        default: 0,
+        dependsOn: ["snipeTaxPips", "snipeDecaySeconds"],
+        disclose: "The tax a guarded buy pays once the decay ends, for the rest of the guard.",
+    },
+    {
+        name: "snipeDecaySeconds",
+        type: "uint16",
+        unit: "seconds",
+        where: "bind",
+        // A floor exists only with a decay; a decay needs a guard and a launch tax above its floor (HookrRules._validate).
+        min: (cfg) => (n(cfg, "snipeFloorPips") > 0 ? 1 : 0),
+        // r31: an hour, or the guard's own length at the launch block when it is longer (HookrRules._validate).
+        max: (cfg, ctx) => guarded(cfg) && n(cfg, "snipeTaxPips") > n(cfg, "snipeFloorPips")
+            ? maxSnipeDecaySeconds(big(cfg, "guardEndBlock"), ctx.blockNumber)
+            : 0,
+        default: (ctx, cfg) => guarded(cfg) && n(cfg, "snipeTaxPips") > 0
+            ? Math.min(300, maxSnipeDecaySeconds(big(cfg, "guardEndBlock"), ctx.blockNumber))
+            : 0,
+        dependsOn: ["guardEndBlock", "snipeTaxPips", "snipeFloorPips"],
+        disclose: "Zero charges the launch tax flat for the whole guard. The decay is counted in seconds from the launch, the " +
+            "guard in parent blocks, and the per-block buy cap grows as the tax falls. It runs up to an hour, or over the " +
+            "whole guard when the guard is longer.",
+    },
+    {
+        name: "snipeCurve",
+        type: "uint8",
+        unit: "raw",
+        where: "bind",
+        // RulesKnobs.snipeCurve (r31): another curve than linear only where the Snipe decays (HookrRules._checkKnobs).
+        min: 0,
+        max: (cfg) => (decaying(cfg) ? SNIPE_CURVE.step : SNIPE_CURVE.linear),
+        default: SNIPE_CURVE.linear,
+        dependsOn: ["snipeDecaySeconds"],
+        disclose: "How the tax falls over the decay: 0 linear (the default), 1 front-loaded (what is left to fall halves every " +
+            "eighth of the decay), 2 step (eight equal steps, held through each eighth). A curve other than linear goes " +
+            "through launchFamily; every other launch binds the linear curve.",
+    },
+];
+/**
+ * Hookr dynamic fees: the root simulates each swap and the Rules price its move away from a time-anchored reference
+ * price, up to maxFeePips. A dynamic fee pool binds `abi.encode(RulesConfig, RulesKnobs)` (r31): a swap carries the
+ * pool's anchor to its end price only when its quote covers minLiquidity between the two prices, and the reference
+ * follows the pool's tempo (window, reset, carry, counted move). Its span, sensitivity and protocol share stay within
+ * HookrDynamicFee's reach bound.
+ */
+const dynamicTempo = (name) => (_ctx, cfg) => !dynamicFeeOn(cfg)
+    ? 0
+    : {
+        windowSeconds: DYNAMIC_FEE_PARAMETERS.window,
+        resetSeconds: DYNAMIC_FEE_PARAMETERS.reset,
+        carryBps: DYNAMIC_FEE_PARAMETERS.carryBps,
+        moveTicks: DYNAMIC_FEE_PARAMETERS.moveTicks,
+    }[name];
+const TEMPO_DISCLOSURE = "A tempo off the default goes through launchFamily; every other launch binds the default (30 s window, 120 s " +
+    "reset, 75% carry, 200-tick move).";
+const DYNAMIC_FEE = [
+    {
+        name: "maxFeePips",
+        type: "uint24",
+        unit: "pips",
+        where: "bind",
+        min: (cfg) => (n(cfg, "dynamicFeeSens") === 0 ? n(cfg, "baseLpFeePips") : n(cfg, "baseLpFeePips") + 1),
+        // r31 (N09): within the reach bound at the configuration's sensitivity and protocol share.
+        max: (cfg) => n(cfg, "dynamicFeeSens") === 0
+            ? n(cfg, "baseLpFeePips")
+            : Math.min(MAX_LP, n(cfg, "baseLpFeePips") + reachSpan(cfg)),
+        default: (_ctx, cfg) => Math.min(n(cfg, "baseLpFeePips") + 20_000, MAX_LP),
+        dependsOn: ["baseLpFeePips", "dynamicFeeSens", "protocolShareBps"],
+    },
+    {
+        name: "dynamicFeeSens",
+        type: "uint16",
+        unit: "raw",
+        where: "bind",
+        // On exactly when maxFeePips is above base; any sensitivity from 1 to 10 at any tick spacing that keeps the span
+        // within the reach bound (span x sens^2 at most MAX_REACH, and span x share x (432 - sens^2) at most
+        // MAX_RESERVE x 432): the first term caps the sensitivity, the second floors it.
+        min: (cfg) => dynamicFeeOff(cfg)
+            ? 0
+            : first(1, 10, (v) => BigInt(span(cfg)) *
+                BigInt(n(cfg, "protocolShareBps")) *
+                (DYNAMIC_FEE_REACH.reserveScale - BigInt(v * v)) <=
+                DYNAMIC_FEE_REACH.maxReserve * DYNAMIC_FEE_REACH.reserveScale),
+        max: (cfg) => dynamicFeeOff(cfg) ? 0 : last(1, 10, (v) => BigInt(span(cfg)) * BigInt(v * v) <= DYNAMIC_FEE_REACH.maxReach),
+        default: (_ctx, cfg) => (dynamicFeeOff(cfg) ? 0 : 5),
+        dependsOn: ["maxFeePips", "baseLpFeePips", "protocolShareBps"],
+    },
+    {
+        name: "minLiquidity",
+        type: "uint96",
+        unit: "raw",
+        where: "bind",
+        // RulesKnobs.minDynamicFeeLiquidity: HookrRules binds 1 to 2^96 - 1 with dynamic fees and nothing without. A
+        // Launcher member's is its launch liquidity over its divisor (HookrLauncher._rulesData), so with
+        // `launchLiquidity` it is pinned.
+        min: (cfg, ctx) => !dynamicFeeOn(cfg)
+            ? 0n
+            : ctx.launchLiquidity !== undefined
+                ? dynamicFeeMinLiquidity(ctx.launchLiquidity, divisorOf(cfg))
+                : 1n,
+        max: (cfg, ctx) => !dynamicFeeOn(cfg)
+            ? 0n
+            : ctx.launchLiquidity !== undefined
+                ? dynamicFeeMinLiquidity(ctx.launchLiquidity, divisorOf(cfg))
+                : U96,
+        default: (ctx, cfg) => !dynamicFeeOn(cfg) ? 0n : dynamicFeeMinLiquidity(ctx.launchLiquidity ?? 0n, divisorOf(cfg)),
+        dependsOn: ["dynamicFeeSens", "dynamicFeeLiquidityDivisor"],
+        hidden: true,
+        disclose: `Set by the Launcher: launch liquidity / ${DYNAMIC_FEE_LIQUIDITY_DIVISOR}, or the member's own divisor through launchFamily.`,
+    },
+    {
+        name: "dynamicFeeLiquidityDivisor",
+        type: "uint16",
+        unit: "raw",
+        where: "launch",
+        // launchFamily's MemberKnobs.dynamicFeeLiquidityDivisor (HookrLaunchChecks.familyBounds): 2 to 10,000 on a dynamic
+        // fee member, zero for DYNAMIC_FEE_LIQUIDITY_DIVISOR; a member without dynamic fees takes only zero.
+        zeroIsOff: true,
+        min: (cfg) => (dynamicFeeOn(cfg) ? Number(RELEASE_CONSTANTS.LAUNCH_MIN_DYNAMIC_FEE_LIQUIDITY_DIVISOR) : 0),
+        max: (cfg) => (dynamicFeeOn(cfg) ? Number(RELEASE_CONSTANTS.LAUNCH_MAX_DYNAMIC_FEE_LIQUIDITY_DIVISOR) : 0),
+        default: 0,
+        dependsOn: ["dynamicFeeSens"],
+        disclose: `Through launchFamily only: the pool's minimum dynamic fee liquidity is its launch liquidity over this; zero keeps ${DYNAMIC_FEE_LIQUIDITY_DIVISOR}.`,
+    },
+    {
+        name: "windowSeconds",
+        type: "uint16",
+        unit: "seconds",
+        where: "bind",
+        min: (cfg) => (dynamicFeeOn(cfg) ? RULES_KNOB_BOUNDS.minWindowSeconds : 0),
+        // The reset runs at least two windows (HookrRules._checkKnobs), so the window is at most half the reset.
+        max: (cfg) => dynamicFeeOn(cfg) ? Math.min(RULES_KNOB_BOUNDS.maxWindowSeconds, Math.floor(n(cfg, "resetSeconds") / 2)) : 0,
+        default: dynamicTempo("windowSeconds"),
+        dependsOn: ["dynamicFeeSens", "resetSeconds"],
+        disclose: "Without an anchor move the reference steps toward the anchor once per window. " + TEMPO_DISCLOSURE,
+    },
+    {
+        name: "resetSeconds",
+        type: "uint16",
+        unit: "seconds",
+        where: "bind",
+        // At least twice the window and the reset floor, on the reset step's grid.
+        min: (cfg) => {
+            if (!dynamicFeeOn(cfg))
+                return 0;
+            const least = Math.max(2 * n(cfg, "windowSeconds"), RULES_KNOB_BOUNDS.minResetSeconds);
+            const step = RULES_KNOB_BOUNDS.resetStepSeconds;
+            return Math.ceil(least / step) * step;
+        },
+        max: (cfg) => (dynamicFeeOn(cfg) ? RULES_KNOB_BOUNDS.maxResetSeconds : 0),
+        grid: RULES_KNOB_BOUNDS.resetStepSeconds,
+        default: dynamicTempo("resetSeconds"),
+        dependsOn: ["dynamicFeeSens", "windowSeconds"],
+        disclose: "The reference joins the anchor after the reset, and steps once per reset while the anchor keeps moving.",
+    },
+    {
+        name: "carryBps",
+        type: "uint16",
+        unit: "bps",
+        where: "bind",
+        min: 0,
+        max: (cfg) => (dynamicFeeOn(cfg) ? RULES_KNOB_BOUNDS.maxCarryBps : 0),
+        grid: RULES_KNOB_BOUNDS.carryStepBps,
+        default: dynamicTempo("carryBps"),
+        dependsOn: ["dynamicFeeSens"],
+        disclose: "The share of its distance to the anchor the reference keeps at each step.",
+    },
+    {
+        name: "moveTicks",
+        type: "uint24",
+        unit: "ticks",
+        where: "bind",
+        min: (cfg) => (dynamicFeeOn(cfg) ? RULES_KNOB_BOUNDS.minMoveTicks : 0),
+        max: (cfg) => (dynamicFeeOn(cfg) ? RULES_KNOB_BOUNDS.maxMoveTicks : 0),
+        default: dynamicTempo("moveTicks"),
+        dependsOn: ["dynamicFeeSens"],
+        disclose: "A move counts when it carries the anchor at least this far from where the last counted move left it.",
+    },
+];
+/** launchFamily's MemberKnobs.dynamicFeeLiquidityDivisor of a configuration, zero when it has none. */
+function divisorOf(cfg) {
+    return cfg.dynamicFeeLiquidityDivisor === undefined ? 0 : n(cfg, "dynamicFeeLiquidityDivisor");
+}
+/** Auto Burn: a share of every buy's subject output is burned. */
+const AUTO_BURN = [
+    {
+        name: "burnBps",
+        type: "uint16",
+        unit: "bps",
+        where: "bind",
+        min: 0,
+        max: (cfg) => 1_000 - n(cfg, "lpBps"),
+        default: 100,
+        dependsOn: ["lpBps"],
+        disclose: "The protocol share turns that part of the burn into a quote take.",
+    },
+];
+/** LP Rewards: an LP fee on buys on top of the base fee. */
+const LP_REWARDS = [
+    {
+        name: "lpBps",
+        type: "uint16",
+        unit: "bps",
+        where: "bind",
+        min: (cfg) => (n(cfg, "royaltyBps") !== 0 ? 1 : 0),
+        max: (cfg) => last(0, 1_000 - n(cfg, "burnBps"), (v) => lpRoom(cfg, { lpBps: v })),
+        default: 200,
+        dependsOn: ["burnBps", "royaltyBps", "protocolShareBps", "baseLpFeePips"],
+        disclose: "LPs keep lpBps less the protocol share.",
+    },
+];
+/** Royalty: a share of LP Rewards paid to a fixed recipient. */
+const ROYALTY = [
+    {
+        name: "royaltyBps",
+        type: "uint16",
+        unit: "bps",
+        where: "bind",
+        min: (cfg) => (big(cfg, "royaltyTo") === 0n ? 0 : first(1, 1_000, (v) => lpRoom(cfg, { royaltyBps: v }))),
+        max: (cfg) => (big(cfg, "royaltyTo") === 0n || n(cfg, "lpBps") === 0 ? 0 : 1_000),
+        default: 0,
+        dependsOn: ["royaltyTo", "lpBps"],
+        disclose: "Royalty is a share of LP Rewards, not of volume.",
+    },
+    {
+        name: "royaltyTo",
+        type: "address",
+        unit: "address",
+        where: "bind",
+        min: (cfg) => (n(cfg, "royaltyBps") !== 0 ? 1 : 0),
+        max: (cfg) => (n(cfg, "royaltyBps") !== 0 ? U160 : 0),
+        default: (ctx, cfg) => (n(cfg, "royaltyBps") !== 0 && ctx.creator ? address(ctx.creator) : ZERO),
+        dependsOn: ["royaltyBps"],
+    },
+];
+/** The protocol share a launch starts with: 2,000 bps (20%), or the Rules minimum when that is higher. */
+export const DEFAULT_PROTOCOL_SHARE_BPS = 2_000;
+/**
+ * The effective floor from the context: the larger of the Rules minimum and the treasury's governed floor, each
+ * refused unless a HookrRules or a HookrTreasury could hold it (an integer from 0 to 5,000).
+ */
+function minShareOf(ctx) {
+    const m = ctx.minProtocolShareBps ?? 0;
+    assert(Number.isSafeInteger(m) && m >= 0 && m <= MAX_PROTOCOL_SHARE_BPS, `minProtocolShareBps ${m} is not a HookrRules minimum (an integer from 0 to ${MAX_PROTOCOL_SHARE_BPS})`);
+    const g = ctx.ruleShareFloorBps ?? 0;
+    assert(Number.isSafeInteger(g) && g >= 0 && g <= MAX_RULE_SHARE_FLOOR_BPS, `ruleShareFloorBps ${g} is not a HookrTreasury floor (an integer from 0 to ${MAX_RULE_SHARE_FLOOR_BPS})`);
+    return effectiveShareFloor(m, g);
+}
+/**
+ * Protocol share: the part of LP Rewards, Auto Burn, the dynamic fee and the Snipe tax paid to the protocol as a
+ * quote take. The creator chooses it from the effective floor (the larger of `HookrRules.minProtocolShareBps` and the
+ * treasury's governed floor) to 5,000 bps. `integrator` names the app the launch goes through: on a pool with one,
+ * the integrator is paid its listed rate of every Hookr share of those rules (`splitProtocolShare`), never of the arb
+ * recapture cut.
+ */
+const PROTOCOL_SHARE = [
+    {
+        name: "protocolShareBps",
+        type: "uint16",
+        unit: "bps",
+        where: "bind",
+        // At least the Rules minimum, and enough that base + LP Rewards stay within 600,000 pips: the share comes out of
+        // LP Rewards, so near the ceiling it has a floor of its own.
+        min: (cfg, ctx) => first(minShareOf(ctx), MAX_PROTOCOL_SHARE_BPS, (v) => lpRoom(cfg, { protocolShareBps: v })),
+        // r31 (N09): a dynamic fee pool's share also keeps its span within the reach bound.
+        max: (cfg) => !dynamicFeeOn(cfg)
+            ? MAX_PROTOCOL_SHARE_BPS
+            : last(0, MAX_PROTOCOL_SHARE_BPS, (v) => withinDynamicFeeReach(span(cfg), n(cfg, "dynamicFeeSens"), v)),
+        default: (ctx) => Math.max(DEFAULT_PROTOCOL_SHARE_BPS, minShareOf(ctx)),
+        dependsOn: ["lpBps", "royaltyBps", "baseLpFeePips", "maxFeePips", "dynamicFeeSens"],
+        disclose: "The protocol's share of LP Rewards, Auto Burn, the dynamic fee and the Snipe tax, paid as a quote take, from " +
+            "the Rules minimum to 50%. Any take-bearing rule turns off the fee-only path for the pool's whole life.",
+    },
+    {
+        name: "integrator",
+        type: "address",
+        unit: "address",
+        where: "bind",
+        // A set, not a range: zero, or an address on the treasury's integrator list, which only the chain holds. With
+        // ParamContext.integrators the checked encoder refuses one off the list; HookrRules refuses it at bind either way.
+        min: 0,
+        max: U160,
+        default: (ctx) => (ctx.integrator ? address(ctx.integrator, true) : ZERO),
+        hidden: true,
+        disclose: "The app the launch goes through, if it is a listed integrator: it is paid its listed rate (at most half) of " +
+            "the protocol's share of these rules on this pool, frozen at launch. The buyer pays the same either way.",
+    },
+];
+/** Fee advisory Config: a keeper-set surcharge within an immutable cap. */
+const FEE_ADVISORY = [
+    {
+        name: "cap",
+        type: "uint24",
+        unit: "pips",
+        where: "advisoryData",
+        min: (cfg) => Math.max(1, n(cfg, "surcharge") + Math.max(n(cfg, "premium0"), n(cfg, "premium1"))),
+        max: (_c, ctx) => limitOf(ctx),
+        default: (ctx) => Math.min(10_000, limitOf(ctx)),
+        dependsOn: ["surcharge", "premium0", "premium1"],
+    },
+    {
+        name: "surcharge",
+        type: "uint24",
+        unit: "pips",
+        where: "advisoryData",
+        min: 0,
+        max: (cfg) => n(cfg, "cap") - Math.max(n(cfg, "premium0"), n(cfg, "premium1")),
+        default: (_ctx, cfg) => Math.min(500, n(cfg, "cap")),
+        dependsOn: ["cap", "premium0", "premium1"],
+    },
+    {
+        name: "premium0",
+        type: "uint24",
+        unit: "pips",
+        where: "advisoryData",
+        min: 0,
+        max: (cfg) => n(cfg, "cap") - n(cfg, "surcharge"),
+        default: 0,
+        dependsOn: ["cap", "surcharge"],
+        disclose: "Premium on zeroForOne swaps: buys when the quote is currency0 (`feePremiumSides`).",
+    },
+    {
+        name: "premium1",
+        type: "uint24",
+        unit: "pips",
+        where: "advisoryData",
+        min: 0,
+        max: (cfg) => n(cfg, "cap") - n(cfg, "surcharge"),
+        default: 0,
+        dependsOn: ["cap", "surcharge"],
+        disclose: "Premium on oneForZero swaps: buys when the quote is currency1 (`feePremiumSides`).",
+    },
+    { name: "maxStep", type: "uint24", unit: "pips", where: "advisoryData", min: 1, max: U24, default: 1_000 },
+    {
+        name: "minInterval",
+        type: "uint32",
+        unit: "seconds",
+        where: "advisoryData",
+        min: 1,
+        // HookrFeeAdvisory.MAX_MIN_INTERVAL: one day.
+        max: RELEASE_CONSTANTS.FEE_ADVISORY_MAX_MIN_INTERVAL,
+        default: 60,
+        ui: { min: 60, max: RELEASE_CONSTANTS.FEE_ADVISORY_MAX_MIN_INTERVAL },
+    },
+    {
+        name: "maxTtl",
+        type: "uint32",
+        unit: "seconds",
+        where: "advisoryData",
+        min: 1,
+        max: RELEASE_CONSTANTS.FEE_ADVISORY_MAX_TTL,
+        default: 3_600,
+    },
+];
+function limitOf(ctx) {
+    assert(ctx.advisoryLimit !== undefined, "Fee advisory knobs need the advisory limit (feeAdvisoryLimit)");
+    return ctx.advisoryLimit;
+}
+function tierCapOf(ctx) {
+    assert(ctx.tierCap !== undefined, "Session knobs need the tier cap");
+    return ctx.tierCap;
+}
+/** The five session tiers, two ramps and flags shared by fee-advisory tiers and the session advisory. */
+function sessionParams(maxRamp, defaults) {
+    const tiers = ["regularPips", "preMarketPips", "afterHoursPips", "overnightPips", "closedPips"].map((name, i) => ({
+        name,
+        type: "uint24",
+        unit: "pips",
+        where: "advisoryData",
+        min: 0,
+        max: (_c, ctx) => tierCapOf(ctx),
+        default: (ctx) => Math.min(defaults[i], tierCapOf(ctx)),
+    }));
+    return [
+        ...tiers,
+        {
+            name: "openRampSeconds",
+            type: "uint16",
+            unit: "seconds",
+            where: "advisoryData",
+            min: 0,
+            max: (cfg) => maxRamp - n(cfg, "closeRampSeconds"),
+            default: defaults[5],
+            dependsOn: ["closeRampSeconds"],
+        },
+        {
+            name: "closeRampSeconds",
+            type: "uint16",
+            unit: "seconds",
+            where: "advisoryData",
+            min: 0,
+            max: (cfg) => maxRamp - n(cfg, "openRampSeconds"),
+            default: defaults[6],
+            dependsOn: ["openRampSeconds"],
+        },
+        {
+            name: "flags",
+            type: "uint8",
+            unit: "mask",
+            where: "advisoryData",
+            min: 0,
+            max: RELEASE_CONSTANTS.SESSION_UNCOVERED_AS_CLOSED,
+            default: RELEASE_CONSTANTS.SESSION_UNCOVERED_AS_CLOSED,
+            options: [
+                { bit: 0, name: "UNCOVERED_AS_CLOSED", disclose: "A weekday outside the calendar is charged the closed tier." },
+            ],
+        },
+    ];
+}
+const SESSION_DEFAULTS = [0, 2_000, 2_000, 4_000, 6_000, 1_800, 900];
+const PAIR_GAS_FLOOR = {
+    fee: RELEASE_CONSTANTS.FEE_ADVISORY_MIN_PAIR_GAS,
+    feeTiered: RELEASE_CONSTANTS.FEE_ADVISORY_MIN_TIERED_GAS,
+    session: RELEASE_CONSTANTS.SESSION_ADVISORY_MIN_PAIR_GAS,
+};
+const advised = (cfg) => big(cfg, "advisory") !== 0n;
+/** Pair root: a Hookr root for one existing pair, with an optional fee or session advisory. */
+const PAIR_ROOT = [
+    { name: "tickSpacing", type: "int24", unit: "ticks", where: "launch", min: 1, max: MAX_TICK_SPACING, default: 60 },
+    {
+        name: "baseLpFeePips",
+        type: "uint24",
+        unit: "pips",
+        where: "launch",
+        min: 0,
+        max: (cfg) => RELEASE_CONSTANTS.PAIR_ROOT_MAX_LP_FEE_PIPS - n(cfg, "advisoryCapPips"),
+        default: 3_000,
+        dependsOn: ["advisoryCapPips"],
+    },
+    { name: "advisory", type: "address", unit: "address", where: "launch", min: 0, max: U160, default: ZERO },
+    {
+        name: "advisoryCapPips",
+        type: "uint24",
+        unit: "pips",
+        where: "launch",
+        min: (cfg) => (advised(cfg) ? 1 : 0),
+        max: (cfg, ctx) => advised(cfg)
+            ? Math.min(pairAdmissionOf(ctx).maxLpFeePips, RELEASE_CONSTANTS.PAIR_ROOT_MAX_LP_FEE_PIPS - n(cfg, "baseLpFeePips"))
+            : 0,
+        default: (ctx, cfg) => advised(cfg)
+            ? Math.min(10_000, pairAdmissionOf(ctx).maxLpFeePips, RELEASE_CONSTANTS.PAIR_ROOT_MAX_LP_FEE_PIPS - n(cfg, "baseLpFeePips"))
+            : 0,
+        dependsOn: ["advisory", "baseLpFeePips"],
+    },
+    {
+        name: "advisoryFailOpen",
+        type: "bool",
+        unit: "bool",
+        where: "launch",
+        min: 0,
+        // HookrRootFactory deploys a fail-open root only on a fail-open, fee-only admission without a quote take, the
+        // rule HookrRoot applies to its own pools; it defaults to what the admission allows.
+        max: (cfg, ctx) => (advised(cfg) && failOpenAdmitted(ctx) ? 1 : 0),
+        default: (ctx, cfg) => advised(cfg) && failOpenAdmitted(ctx),
+        dependsOn: ["advisory"],
+        disclose: "On advisory failure, true charges the cap and false reverts the swap.",
+    },
+    {
+        name: "maxLpFeePips",
+        type: "uint24",
+        unit: "pips",
+        where: "launch",
+        min: (cfg) => n(cfg, "baseLpFeePips") + n(cfg, "advisoryCapPips"),
+        max: RELEASE_CONSTANTS.PAIR_ROOT_MAX_LP_FEE_PIPS,
+        default: (_ctx, cfg) => n(cfg, "baseLpFeePips") + n(cfg, "advisoryCapPips"),
+        dependsOn: ["baseLpFeePips", "advisoryCapPips"],
+        hidden: true,
+    },
+    {
+        name: "advisoryGasLimit",
+        type: "uint32",
+        unit: "gas",
+        where: "launch",
+        min: (cfg, ctx) => (advised(cfg) ? (ctx.pairAdvisoryKind ? PAIR_GAS_FLOOR[ctx.pairAdvisoryKind] : 1) : 0),
+        max: (cfg, ctx) => advised(cfg) ? Math.min(pairAdmissionOf(ctx).gasLimit, RELEASE_CONSTANTS.PAIR_ROOT_MAX_ADVISORY_GAS) : 0,
+        default: (ctx, cfg) => advised(cfg) ? Math.min(pairAdmissionOf(ctx).gasLimit, RELEASE_CONSTANTS.PAIR_ROOT_MAX_ADVISORY_GAS) : 0,
+        dependsOn: ["advisory"],
+        hidden: true,
+    },
+];
+/** Whether the pair root's factory admission lets it fail open: fail-open, fee-only and without a quote take. */
+function failOpenAdmitted(ctx) {
+    const a = ctx.pairAdmission;
+    return a?.failOpen === true && a.feeOnly === true && (a.maxQuoteTakePips ?? 0) === 0;
+}
+function pairAdmissionOf(ctx) {
+    assert(ctx.pairAdmission !== undefined, "An advised pair root needs its advisory's factory admission");
+    return ctx.pairAdmission;
+}
+/** HookrComplianceGuard flag: also check the recipient. */
+export const COMPLIANCE_CHECK_BENEFICIARY = 1;
+/** HookrComplianceGuard flag: sellers need a credential too. */
+export const COMPLIANCE_KYC_ON_SELL = 2;
+/** HookrComplianceGuard flag: sells stop too while the sanctions source is down. */
+export const COMPLIANCE_HALT_SELLS_WHEN_SOURCE_DOWN = 4;
+/** HookrComplianceGuard flag: the subject enforces transfer restrictions; needs a zero subject take. */
+export const COMPLIANCE_RESTRICTED_SUBJECT = 8;
+/** HookrComplianceGuard flag: accept curated-router swaps; needs RESTRICTED_SUBJECT or no list. */
+export const COMPLIANCE_ACCEPT_CURATED = 16;
+/** HookrComplianceGuard flag: permitted senders other than the launcher may add liquidity. */
+export const COMPLIANCE_DIRECT_LP_IF_PERMITTED = 32;
+/** Every HookrComplianceGuard flag. */
+export const COMPLIANCE_ALL_FLAGS = 63;
+/** HookrComplianceGuard.MIN_ADVISORY_GAS. */
+export const COMPLIANCE_MIN_ADVISORY_GAS = 150_000;
+/** Compliance guard terms: a credential list, required and blocked tiers, and flags. */
+const COMPLIANCE = [
+    { name: "listId", type: "bytes32", unit: "bytes32", where: "advisoryData", min: 0, max: U256, default: ZERO_HASH },
+    { name: "requireAll", type: "uint32", unit: "mask", where: "advisoryData", min: 0, max: U32, default: 0 },
+    {
+        name: "blockAny",
+        type: "uint32",
+        unit: "mask",
+        where: "advisoryData",
+        min: 0,
+        max: U32,
+        default: 0,
+        disclose: "No tier may be both required and blocked.",
+    },
+    {
+        name: "flags",
+        type: "uint16",
+        unit: "mask",
+        where: "advisoryData",
+        min: 0,
+        max: COMPLIANCE_ALL_FLAGS,
+        default: COMPLIANCE_CHECK_BENEFICIARY,
+        options: [
+            { bit: 0, name: "CHECK_BENEFICIARY" },
+            { bit: 1, name: "KYC_ON_SELL" },
+            {
+                bit: 2,
+                name: "HALT_SELLS_WHEN_SOURCE_DOWN",
+                disclose: "An outage of the sanctions source freezes every exit until it recovers. Opt in explicitly.",
+            },
+            { bit: 3, name: "RESTRICTED_SUBJECT", hidden: true, disclose: "Derived from the subject token." },
+            { bit: 4, name: "ACCEPT_CURATED" },
+            { bit: 5, name: "DIRECT_LP_IF_PERMITTED" },
+        ],
+    },
+];
+/** HookrLauncher.MAX_DEV_BUY_BPS: the most of the supply, in basis points, a creator holds when a dev-buy launch returns. */
+export const MAX_DEV_BUY_BPS = Number(RELEASE_CONSTANTS.LAUNCHER_MAX_DEV_BUY_BPS);
+/** HookrLauncher.MAX_DEV_BUY_LOCK_BLOCKS: the longest DevBuy.lockBlocks, 365 days of 12-second parent blocks. */
+export const MAX_DEV_BUY_LOCK_BLOCKS = Number(RELEASE_CONSTANTS.LAUNCHER_MAX_DEV_BUY_LOCK_BLOCKS);
+/** Largest DevBuy.quoteIn the Launcher swaps: it negates it into an int256 amountSpecified bounded by int128. */
+export const MAX_DEV_BUY_QUOTE_IN = I128;
+/**
+ * The lock a launch with a dev buy starts with, in seconds: 7 days, the owner's default. The `lockBlocks` knob takes it
+ * in parent blocks at the chain's clock, the measured block time the Anti-Snipe guard default also uses
+ * (`ParamContext.blockTimeSeconds`, default 12): 50,400 blocks at 12 seconds.
+ */
+export const DEFAULT_DEV_BUY_LOCK_SECONDS = 7 * 86_400;
+/** Parent blocks covering a dev-buy lock of `seconds` at the measured block time, rounded up (`guardBlocksFor`) and at
+ *  most MAX_DEV_BUY_LOCK_BLOCKS. */
+export function devBuyLockBlocksFor(seconds, blockTimeSeconds) {
+    const blocks = guardBlocksFor(seconds, blockTimeSeconds);
+    return blocks < BigInt(MAX_DEV_BUY_LOCK_BLOCKS) ? Number(blocks) : MAX_DEV_BUY_LOCK_BLOCKS;
+}
+/**
+ * Why the member a dev buy names cannot take it, or null when it can: HookrLauncher._checkBuy's InvalidDevBuy checks on
+ * the member (r31, T39). An unguarded member (guardEndBlock zero) takes a dev buy with no Snipe and no cap; a guarded
+ * one needs its guard past `blockNumber`, a Snipe and a per-block cap of at least `quoteIn`.
+ */
+export function devBuyMemberRefusal(r, quoteIn, blockNumber) {
+    if (r === undefined)
+        return "The dev buy names no family member";
+    const guardEnd = BigInt(r.guardEndBlock);
+    if (guardEnd === 0n)
+        return null;
+    if (blockNumber !== undefined && guardEnd <= blockNumber)
+        return "The dev buy's guarded member needs its Anti-Snipe guard past the launch block";
+    if (r.snipeTaxPips === 0)
+        return "The dev buy's guarded member needs an Anti-Snipe tax (snipeTaxPips above zero)";
+    if (r.maxBuyQuoteAmount < quoteIn)
+        return `The dev buy's quoteIn ${quoteIn} is above its member's per-block buy cap ${r.maxBuyQuoteAmount}`;
+    return null;
+}
+/**
+ * The largest quoteIn the dev buy's member admits: its per-block buy cap on a guarded member, the type's bound on an
+ * unguarded one, zero when it cannot take a dev buy at all.
+ */
+function devBuyRoom(cfg, ctx) {
+    if (ctx.newToken === false || ctx.launchMembers === undefined)
+        return 0n;
+    const r = ctx.launchMembers[n(cfg, "member")];
+    if (r === undefined || devBuyMemberRefusal(r, 0n, ctx.blockNumber) !== null)
+        return 0n;
+    if (BigInt(r.guardEndBlock) === 0n)
+        return I128;
+    return BigInt(r.maxBuyQuoteAmount) < I128 ? BigInt(r.maxBuyQuoteAmount) : I128;
+}
+const buying = (cfg) => big(cfg, "quoteIn") !== 0n;
+/**
+ * Dev buy (HookrLauncher.DevBuy): the creator's own first buy on one member of a new-token family, made inside the
+ * launch right after that member's liquidity add and delivered to the creator. Off by default (quoteIn zero, a plain
+ * launch). It pays every guarded-buy leg at the launch tax, counts against the member's per-block cap and closes the
+ * launch block to other buys on that member; the creator holds at most MAX_DEV_BUY_BPS (5%) of the supply, dev-bought
+ * and unplaced together, when the launch returns.
+ */
+const DEV_BUY = [
+    {
+        name: "member",
+        type: "uint8",
+        unit: "raw",
+        where: "launch",
+        min: 0,
+        max: (cfg, ctx) => !buying(cfg) ? 0 : ctx.launchMembers !== undefined ? Math.max(ctx.launchMembers.length - 1, 0) : 7,
+        default: 0,
+        dependsOn: ["quoteIn"],
+        disclose: "The member whose pool takes the dev buy. A guarded member needs its guard past the launch block, a Snipe tax " +
+            "and a per-block buy cap of at least the buy; an unguarded member takes it with no Snipe and no cap.",
+    },
+    {
+        name: "quoteIn",
+        type: "uint128",
+        unit: "raw",
+        where: "launch",
+        zeroIsOff: true,
+        min: 1,
+        // HookrLauncher._checkBuy: at most a guarded member's maxBuyQuoteAmount (it needs a Snipe); any amount up to
+        // 2^127 - 1 on an unguarded member.
+        max: (cfg, ctx) => devBuyRoom(cfg, ctx),
+        default: 0,
+        dependsOn: ["member"],
+        disclose: "The exact quote the dev buy spends, collected with the member's liquidity budget. On a guarded member it pays " +
+            "the full launch Anti-Snipe tax, and on any member every other buy leg; the creator ends the launch holding at " +
+            "most 5% of the supply, dev-bought and unplaced together.",
+    },
+    {
+        name: "minSubjectOut",
+        type: "uint128",
+        unit: "raw",
+        where: "launch",
+        min: (cfg) => (buying(cfg) ? 1 : 0),
+        max: (cfg) => (buying(cfg) ? U128 : 0n),
+        default: 0,
+        dependsOn: ["quoteIn"],
+        hidden: true,
+        disclose: "Set by the SDK from an eth_call quote of the launch less the slippage (quoteDevBuy).",
+    },
+    {
+        name: "lockBlocks",
+        type: "uint32",
+        unit: "blocks",
+        where: "launch",
+        min: 0,
+        max: (cfg) => (buying(cfg) ? MAX_DEV_BUY_LOCK_BLOCKS : 0),
+        // With a dev buy: 7 days in parent blocks at the measured block time; without one it stays zero (a plain launch).
+        default: (ctx, cfg) => (buying(cfg) ? devBuyLockBlocksFor(DEFAULT_DEV_BUY_LOCK_SECONDS, ctx.blockTimeSeconds) : 0),
+        dependsOn: ["quoteIn"],
+        disclose: "Keeps the family's principal locked at least this many parent blocks past the launch block, on top of the " +
+            "guards (at most 2,628,000, 365 days of 12-second blocks). LP fees stay collectable. A launch with a dev buy " +
+            "starts at 7 days (50,400 blocks at 12 seconds).",
+    },
+];
+/**
+ * launchFamily's family-wide terms (HookrLauncher.LaunchParams, HookrLaunchChecks.checkFamily, r31): the lock end every
+ * member's MemberKnobs.lockEndBlock may set, the retained-supply cap and the opening price check's tolerance.
+ */
+const FAMILY = [
+    {
+        name: "lockEndBlock",
+        type: "uint64",
+        unit: "blocks",
+        where: "launch",
+        // Zero, or a parent block from the family's last guard end to the launch block + MAX_LOCK_END_BLOCKS.
+        zeroIsOff: true,
+        min: (_c, ctx) => (ctx.launchMembers ?? []).reduce((m, r) => (BigInt(r.guardEndBlock) > m ? BigInt(r.guardEndBlock) : m), ctx.blockNumber === undefined ? 1n : ctx.blockNumber),
+        max: (_c, ctx) => ctx.blockNumber === undefined
+            ? 2n ** 64n - 1n
+            : ctx.blockNumber + BigInt(RELEASE_CONSTANTS.LAUNCH_MAX_LOCK_END_BLOCKS),
+        default: 0,
+        disclose: "Keeps the family's principal locked until this parent block, on top of the guards and any dev buy's lock " +
+            "(at most 100,000 blocks past the launch block). LP fees stay collectable.",
+    },
+    {
+        name: "maxRetainedBps",
+        type: "uint16",
+        unit: "bps",
+        where: "launch",
+        // A new token's cap on the supply the creator holds when the launch returns; an existing token takes only 10,000.
+        min: (_c, ctx) => (ctx.newToken === false ? 10_000 : 0),
+        max: 10_000,
+        default: 10_000,
+        disclose: "The most of a new token's supply the creator may hold when the launch returns, unplaced supply and dev buys " +
+            "together; 100% is no cap. The dev buy bound of 5% applies on top whenever a dev buy runs.",
+    },
+    {
+        name: "openingToleranceBps",
+        type: "uint16",
+        unit: "bps",
+        where: "launch",
+        // OpeningCheck.toleranceBps: zero checks nothing; otherwise 1 to MAX_OPENING_TOLERANCE_BPS, with one reference
+        // pool per member after the first.
+        zeroIsOff: true,
+        min: 1,
+        max: Number(RELEASE_CONSTANTS.LAUNCH_MAX_OPENING_TOLERANCE_BPS),
+        default: 0,
+        disclose: "Checks that every later pool opens within this distance of pool 1's price, converted through a reference pool " +
+            "you name per pool. It guards your own launch against a mistake; it is not an oracle.",
+    },
+];
+/**
+ * Knob manifest per rule, for the release in this package. `pool` is the PoolKey and PoolConfig of a HookrRoot
+ * launch member; `antiSnipe`, `dynamicFee`, `autoBurn`, `lpRewards`, `royalty` and `protocolShare` together are one
+ * `RulesConfig` and its `RulesKnobs` (r31: with dynamic fees the minimum liquidity and the tempo, and the Snipe curve;
+ * `dynamicFeeLiquidityDivisor` is the member's launchFamily divisor); `feeAdvisory` and `sessionTiers` are
+ * fee-advisory bind data; `sessionAdvisory` is a session Schedule; `pairRoot` the HookrPairRoot params; `compliance`
+ * the HookrComplianceGuard terms; `devBuy` the launch's optional HookrLauncher.DevBuy (`buildLaunchWithBuy`,
+ * `quoteDevBuy`, and each of launchFamily's dev buys); `family` launchFamily's family-wide terms (`buildLaunchFamily`).
+ */
+export const RULE_PARAMS = {
+    pool: POOL,
+    antiSnipe: ANTI_SNIPE,
+    dynamicFee: DYNAMIC_FEE,
+    autoBurn: AUTO_BURN,
+    lpRewards: LP_REWARDS,
+    royalty: ROYALTY,
+    protocolShare: PROTOCOL_SHARE,
+    feeAdvisory: FEE_ADVISORY,
+    sessionTiers: sessionParams(RELEASE_CONSTANTS.SESSION_TIERS_MAX_RAMP_SECONDS, SESSION_DEFAULTS),
+    sessionAdvisory: sessionParams(RELEASE_CONSTANTS.SESSION_ADVISORY_MAX_RAMP_SECONDS, SESSION_DEFAULTS),
+    pairRoot: PAIR_ROOT,
+    compliance: COMPLIANCE,
+    devBuy: DEV_BUY,
+    family: FAMILY,
+};
+/** The rules whose knobs make up a HookrRoot launch member: its pool knobs and one RulesConfig. */
+export const RULES_MEMBER_RULES = [
+    "pool",
+    "antiSnipe",
+    "dynamicFee",
+    "autoBurn",
+    "lpRewards",
+    "royalty",
+    "protocolShare",
+];
+/** Resolves one knob's bounds for `cfg`. */
+export function paramBounds(p, cfg, ctx = {}) {
+    const at = (b) => BigInt(typeof b === "function" ? b(cfg, ctx) : b);
+    return { min: at(p.min), max: at(p.max), grid: BigInt(p.grid ?? 1), zeroIsOff: p.zeroIsOff === true };
+}
+/** Refuses a knob value outside its bounds or off its grid. */
+export function checkParam(rule, p, cfg, ctx = {}) {
+    assert(p.name in cfg, `${rule}.${p.name} missing`);
+    const v = paramValue(cfg[p.name]);
+    const b = paramBounds(p, cfg, ctx);
+    if (b.zeroIsOff && v === 0n)
+        return;
+    assert(v >= b.min && v <= b.max, `${rule}.${p.name} ${v} outside [${b.min}, ${b.max}]`);
+    assert(v % b.grid === 0n, `${rule}.${p.name} ${v} off its ${b.grid} grid`);
+}
+/** Every knob of `rule` outside its bounds in `cfg`, one message each; empty when all are inside. */
+export function ruleParamErrors(rule, cfg, ctx = {}) {
+    const errors = [];
+    for (const p of RULE_PARAMS[rule]) {
+        try {
+            checkParam(rule, p, cfg, ctx);
+        }
+        catch (e) {
+            errors.push(e.message);
+        }
+    }
+    return errors;
+}
+/** Refuses a configuration with any knob of `rule` outside its bounds, naming every such knob. */
+export function checkRuleParams(rule, cfg, ctx = {}) {
+    const errors = ruleParamErrors(rule, cfg, ctx);
+    assert(errors.length === 0, errors.join("; "));
+}
+/** The default configuration of `rule`, knob by knob in manifest order; `base` fixes knobs already chosen. */
+export function defaultRuleParams(rule, ctx = {}, base = {}) {
+    const cfg = { ...base };
+    for (const p of RULE_PARAMS[rule])
+        if (!(p.name in cfg))
+            cfg[p.name] = typeof p.default === "function" ? p.default(ctx, cfg) : p.default;
+    return cfg;
+}
+/** Parent blocks covering `seconds` at the measured block time, rounded up. */
+export function guardBlocksFor(seconds, blockTimeSeconds = DEFAULT_BLOCK_TIME) {
+    assert(Number.isSafeInteger(seconds) && seconds > 0, "Invalid guard length");
+    assert(blockTimeSeconds > 0, "Invalid block time");
+    return BigInt(Math.ceil(seconds / blockTimeSeconds));
+}
+function flat(l) {
+    return {
+        ...l.rules,
+        baseLpFeePips: l.baseLpFeePips,
+        tickSpacing: l.tickSpacing,
+        minLiquidity: l.minLiquidity,
+        windowSeconds: l.windowSeconds,
+        resetSeconds: l.resetSeconds,
+        carryBps: l.carryBps,
+        moveTicks: l.moveTicks,
+        snipeCurve: l.snipeCurve,
+        dynamicFeeLiquidityDivisor: l.dynamicFeeLiquidityDivisor,
+    };
+}
+/** The RulesKnobs a launch member binds: its minLiquidity, its tempo and its Snipe curve. */
+export function rulesKnobsOf(l) {
+    return {
+        minDynamicFeeLiquidity: l.minLiquidity,
+        windowSeconds: l.windowSeconds,
+        resetSeconds: l.resetSeconds,
+        carryBps: l.carryBps,
+        moveTicks: l.moveTicks,
+        snipeCurve: l.snipeCurve,
+    };
+}
+/** Every knob of a HookrRoot launch member at its default. */
+export function defaultRulesLaunch(ctx = {}) {
+    let cfg = {};
+    for (const rule of RULES_MEMBER_RULES)
+        cfg = defaultRuleParams(rule, ctx, cfg);
+    return rulesLaunchOf(cfg);
+}
+/**
+ * Builds a RulesLaunch from a flat knob configuration. The retired pot fields are zero. A Rules knob the configuration
+ * lacks (one written before r31) takes what the Launcher binds without it: the default tempo on a dynamic fee member,
+ * zero otherwise, the linear Snipe curve and the default divisor.
+ */
+export function rulesLaunchOf(cfg) {
+    const dynamic = n(cfg, "dynamicFeeSens") !== 0;
+    const tempo = (key, fallback) => (cfg[key] === undefined ? (dynamic ? fallback : 0) : n(cfg, key));
+    const knob = (key) => (cfg[key] === undefined ? 0 : n(cfg, key));
+    return {
+        baseLpFeePips: n(cfg, "baseLpFeePips"),
+        tickSpacing: n(cfg, "tickSpacing"),
+        minLiquidity: big(cfg, "minLiquidity"),
+        windowSeconds: tempo("windowSeconds", DYNAMIC_FEE_PARAMETERS.window),
+        resetSeconds: tempo("resetSeconds", DYNAMIC_FEE_PARAMETERS.reset),
+        carryBps: tempo("carryBps", DYNAMIC_FEE_PARAMETERS.carryBps),
+        moveTicks: tempo("moveTicks", DYNAMIC_FEE_PARAMETERS.moveTicks),
+        snipeCurve: knob("snipeCurve"),
+        dynamicFeeLiquidityDivisor: knob("dynamicFeeLiquidityDivisor"),
+        rules: {
+            guardEndBlock: n(cfg, "guardEndBlock"),
+            maxFeePips: n(cfg, "maxFeePips"),
+            snipeTaxPips: n(cfg, "snipeTaxPips"),
+            snipeFloorPips: n(cfg, "snipeFloorPips"),
+            snipeDecaySeconds: n(cfg, "snipeDecaySeconds"),
+            dynamicFeeSens: n(cfg, "dynamicFeeSens"),
+            burnBps: n(cfg, "burnBps"),
+            lpBps: n(cfg, "lpBps"),
+            potBps: 0,
+            royaltyBps: n(cfg, "royaltyBps"),
+            protocolShareBps: n(cfg, "protocolShareBps"),
+            potEveryNBuys: 0,
+            maxBuyQuoteAmount: big(cfg, "maxBuyQuoteAmount"),
+            potMinBuyQuote: 0n,
+            royaltyTo: address(`0x${big(cfg, "royaltyTo").toString(16).padStart(40, "0")}`, true),
+            integrator: address(`0x${(cfg.integrator === undefined ? 0n : big(cfg, "integrator")).toString(16).padStart(40, "0")}`, true),
+        },
+    };
+}
+/**
+ * Checks every knob of a launch member against the manifest, HookrRules._validate and _checkKnobs, and returns its
+ * `rulesData`: the bytes HookrRules binds (`encodeRulesData`, r31): `abi.encode(RulesConfig)` without dynamic fees or
+ * a knob off its default, `abi.encode(RulesConfig, RulesKnobs)` otherwise. `ctx.blockNumber` should be the block the
+ * launch lands in; the guard is then checked against the 100,000-block window. A guarded pool needs
+ * `liquidityOwner`, the Launcher. For a Launcher member pass `ctx.launchLiquidity`: the Launcher derives minLiquidity
+ * from it (and the member's divisor) and the manifest pins the knob to that value, so the returned bytes are the ones
+ * launchFamily binds with these MemberKnobs (`launcherRulesData`); launch, launchAdvised and launchWithBuy bind the
+ * default tempo and the linear curve.
+ */
+export function encodeRulesBind(l, ctx = {}) {
+    const cfg = flat(l);
+    const errors = RULES_MEMBER_RULES.flatMap((rule) => ruleParamErrors(rule, cfg, ctx));
+    assert(errors.length === 0, errors.join("; "));
+    checkRulesConfig(l.rules, {
+        baseLpFeePips: l.baseLpFeePips,
+        minProtocolShareBps: ctx.minProtocolShareBps ?? 0,
+        ruleShareFloorBps: ctx.ruleShareFloorBps,
+        integrators: ctx.integrators,
+        refusedIntegrators: ctx.refusedIntegrators,
+        refusedRoyaltyRecipients: ctx.refusedRoyaltyRecipients,
+        minFeePips: ctx.minFeePips,
+        blockNumber: ctx.blockNumber,
+        liquidityOwner: ctx.liquidityOwner,
+    });
+    return encodeRulesData(l.rules, rulesKnobsOf(l));
+}
+/**
+ * Smallest advisory gas each advisory binds with on a HookrRoot member: the fee advisory's bind floor
+ * (`feeAdvisoryMinGas`), HookrSessionAdvisory.MIN_ADVISORY_GAS and HookrComplianceGuard.MIN_ADVISORY_GAS.
+ */
+export const ROOT_ADVISORY_MIN_GAS = {
+    fee: feeAdvisoryMinGas("root", false),
+    feeTiered: feeAdvisoryMinGas("root", true),
+    session: RELEASE_CONSTANTS.SESSION_ADVISORY_MIN_ADVISORY_GAS,
+    compliance: COMPLIANCE_MIN_ADVISORY_GAS,
+};
+/**
+ * Pool caps and gas limits for a launch member (`PoolConfig.caps`, `rulesGasLimit`, `advisoryGasLimit`,
+ * `advisoryPhases`). Caps are the tightest the Rules accept, plus the advisory's admitted maximum so the Root's
+ * reservation leaves the Rules their full ceilings. On a Hookr token's pool pass the minimum it binds as
+ * `ctx.minFeePips`: the quote cap then admits royalty + minimum, and a Rules admission whose quote cap cannot carry it
+ * is refused here, so no launch is built that the bind refuses. The advisory gas is the admission's, which HookrRoot requires
+ * exactly and runs the advisory's bind within, so `advisory.kind` is required: the admission's gas must clear that
+ * advisory's floor (`ROOT_ADVISORY_MIN_GAS`) and the phases must include BEFORE_SWAP (exactly BEFORE_SWAP for the
+ * session advisory). Refuses a configuration the Rules admission caps cannot carry.
+ */
+export function rulesPoolTerms(l, ctx, rulesAdmission, advisory) {
+    checkAdmission(rulesAdmission);
+    assert(rulesAdmission.kind === ADMISSION_KIND.RULES, "Not a Rules admission");
+    const rulesData = encodeRulesBind(l, ctx);
+    // A Hookr token's pool freezes the Hookr minimum: its quote cap must admit royalty + minimum or the bind reverts.
+    const ceilings = rulesFeeCeilings(l.rules, l.baseLpFeePips, ctx.minFeePips ?? 0);
+    let advisoryGasLimit = 0;
+    let advisoryPhases = 0;
+    if (advisory) {
+        const a = advisory.admission;
+        checkAdmission(a);
+        assert(a.kind === ADMISSION_KIND.ADVISORY, "Not an advisory admission");
+        const kind = advisory.kind;
+        assert(Object.hasOwn(ROOT_ADVISORY_MIN_GAS, kind), "An advised member needs its advisory kind");
+        const floor = ROOT_ADVISORY_MIN_GAS[kind];
+        assert(a.gasLimit >= floor, `Advisory admission gas ${a.gasLimit} below the ${kind} bind floor ${floor}`);
+        advisoryGasLimit = a.gasLimit;
+        advisoryPhases = advisory.phases ?? a.phaseMask;
+        assert(advisoryPhases !== 0 && (advisoryPhases & ~a.phaseMask) === 0, "Advisory phases outside the admission");
+        assert(kind === "session" ? advisoryPhases === PHASE.BEFORE_SWAP : (advisoryPhases & PHASE.BEFORE_SWAP) !== 0, `The ${kind} advisory binds only with BEFORE_SWAP${kind === "session" ? " alone" : ""}`);
+    }
+    const caps = poolCapsFor(ceilings, l.baseLpFeePips, advisory?.admission.caps);
+    const seen = rulesBindCaps(caps, rulesAdmission.caps, advisory?.admission.caps);
+    assert(ceilings.maxLpFeePips <= seen.maxLpFeePips &&
+        ceilings.maxQuoteTakePips <= seen.maxQuoteTakePips &&
+        ceilings.maxSubjectTakeBps <= seen.maxSubjectTakeBps, "Rules admission caps below the configuration's ceilings");
+    return { rulesData, caps, rulesGasLimit: rulesAdmission.gasLimit, advisoryGasLimit, advisoryPhases };
+}
+/**
+ * The largest fee-advisory cap a HookrRoot member may bind: min(admission cap, pool LP cap above the Rules' native
+ * ceiling). With `rulesPoolTerms` caps this is the admission cap.
+ */
+export function feeAdvisoryLimit(l, poolCaps, admissionCap) {
+    const room = poolCaps.maxLpFeePips - nativeLpCeiling(l.rules, l.baseLpFeePips, 0);
+    return Math.max(0, Math.min(admissionCap, room));
+}
+/** Which side each fee premium prices: premium0 is zeroForOne, a buy when the quote is currency0. */
+export function feePremiumSides(quoteIsCurrency0) {
+    return quoteIsCurrency0 ? { premium0: "buy", premium1: "sell" } : { premium0: "sell", premium1: "buy" };
+}
+/**
+ * Checked fee-advisory bind data: the Config (and session tiers when given) against the manifest with
+ * `ctx.advisoryLimit`, then the advisory's own checks and the gas floor `feeAdvisoryMinGas(root, tiered)`.
+ * `gasLimit` is the pool's advisory gas. HookrRoot member (`root` "root", the default): the advisory admission's
+ * gas, which HookrRoot requires exactly and runs `bind` within, so at least `FEE_ADVISORY_ROOT_BIND_GAS` (80,000
+ * plain, 110,000 tiered), above the advisory's MIN_ADVISORY_GAS (30,000) and MIN_TIERED_GAS (60,000). Pair root
+ * (`"pair"`): the root's advisoryGasLimit, at least MIN_PAIR_GAS (10,000), or MIN_TIERED_GAS with tiers.
+ */
+export function encodeFeeAdvisoryParams(c, ctx, gasLimit, tiers, root = "root") {
+    checkRuleParams("feeAdvisory", c, ctx);
+    checkFeeAdvisoryConfig(c, limitOf(ctx));
+    if (tiers) {
+        checkRuleParams("sessionTiers", tiers, { ...ctx, tierCap: c.cap });
+        checkSessionTiers(tiers, c.cap);
+    }
+    return encodeFeeAdvisoryBind(c, limitOf(ctx), gasLimit, tiers, root);
+}
+/** Checked session-advisory bind data: the Schedule against the manifest with `ctx.tierCap`. */
+export function encodeSessionScheduleParams(s, ctx) {
+    checkRuleParams("sessionAdvisory", s, ctx);
+    checkSessionSchedule(s, tierCapOf(ctx));
+    return encodeSessionSchedule(s);
+}
+/**
+ * HookrPairRoot params from creator knobs: maxLpFeePips is base plus the advisory cap, advisoryGasLimit the factory
+ * admission's gas (at most 500,000) and advisoryFailOpen false unless `ctx.pairAdmission` is fail-open, fee-only and
+ * without a quote take, each unless given. Checked against the manifest, the constructor and, with `admission` and
+ * `advisoryCodeHash`, the root factory's admission check, which refuses a fail-open root on any other admission.
+ */
+export function pairRootParamsFor(k, ctx = {}, admission) {
+    const partial = { ...k };
+    for (const hidden of ["maxLpFeePips", "advisoryGasLimit", "advisoryFailOpen"])
+        if (partial[hidden] === undefined)
+            delete partial[hidden];
+    const cfg = defaultRuleParams("pairRoot", ctx, partial);
+    checkRuleParams("pairRoot", cfg, ctx);
+    const p = checkPairRootParams({
+        currency0: k.currency0,
+        currency1: k.currency1,
+        tickSpacing: n(cfg, "tickSpacing"),
+        baseLpFeePips: n(cfg, "baseLpFeePips"),
+        maxLpFeePips: n(cfg, "maxLpFeePips"),
+        advisory: k.advisory,
+        advisoryCapPips: n(cfg, "advisoryCapPips"),
+        advisoryGasLimit: n(cfg, "advisoryGasLimit"),
+        advisoryFailOpen: big(cfg, "advisoryFailOpen") === 1n,
+    });
+    if (p.advisory !== ZERO && admission)
+        checkPairRootAdmission(p, admission.admission, admission.advisoryCodeHash);
+    return p;
+}
+const TERMS = [
+    {
+        type: "tuple",
+        components: [
+            { name: "listId", type: "bytes32" },
+            { name: "requireAll", type: "uint32" },
+            { name: "blockAny", type: "uint32" },
+            { name: "flags", type: "uint16" },
+        ],
+    },
+];
+/**
+ * Compliance flags from named options. RESTRICTED_SUBJECT is derived from the subject token, never chosen.
+ */
+export function complianceFlags(o) {
+    return ((o.checkBeneficiary ? COMPLIANCE_CHECK_BENEFICIARY : 0) |
+        (o.kycOnSell ? COMPLIANCE_KYC_ON_SELL : 0) |
+        (o.haltSellsWhenSourceDown ? COMPLIANCE_HALT_SELLS_WHEN_SOURCE_DOWN : 0) |
+        (o.restrictedSubject ? COMPLIANCE_RESTRICTED_SUBJECT : 0) |
+        (o.acceptCurated ? COMPLIANCE_ACCEPT_CURATED : 0) |
+        (o.directLpIfPermitted ? COMPLIANCE_DIRECT_LP_IF_PERMITTED : 0));
+}
+/**
+ * Refuses terms HookrComplianceGuard.bind would refuse: unknown flags, a tier both required and blocked, a missing
+ * list (with `ctx.listExists`), curated swaps on a listed unrestricted subject, and a restricted subject with a
+ * subject take (with `ctx.subjectTakeBps`).
+ */
+export function checkComplianceTerms(t, ctx = {}) {
+    hash(t.listId);
+    checkRuleParams("compliance", t, ctx);
+    assert((t.requireAll & t.blockAny) === 0, "A tier is both required and blocked");
+    if (t.listId !== ZERO_HASH && ctx.listExists !== undefined)
+        assert(ctx.listExists, "Unknown compliance list");
+    assert((t.flags & COMPLIANCE_ACCEPT_CURATED) === 0 ||
+        (t.flags & COMPLIANCE_RESTRICTED_SUBJECT) !== 0 ||
+        BigInt(t.listId) === 0n, "Curated swaps need a restricted subject or no list");
+    if ((t.flags & COMPLIANCE_RESTRICTED_SUBJECT) !== 0 && ctx.subjectTakeBps !== undefined)
+        assert(ctx.subjectTakeBps === 0, "A restricted subject needs a zero subject take");
+}
+/** Checked compliance terms as the guard's canonical 128-byte bind data. */
+export function encodeComplianceTerms(t, ctx = {}) {
+    checkComplianceTerms(t, ctx);
+    return encodeAbiParameters(TERMS, [{ ...t, listId: hash(t.listId) }]);
+}
+/** Decodes compliance bind data, refusing any size or encoding the guard refuses. */
+export function decodeComplianceTerms(data) {
+    assert(/^0x[\da-fA-F]{256}$/.test(data), "Compliance terms must be 128 bytes");
+    // The guard refuses a word above its field's type before decoding (HookrComplianceGuard._decode).
+    const word = (i) => BigInt(`0x${data.slice(2 + 64 * i, 2 + 64 * (i + 1))}`);
+    assert(word(1) < 2n ** 32n && word(2) < 2n ** 32n && word(3) < 2n ** 16n, "Non-canonical compliance terms");
+    const [t] = decodeAbiParameters(TERMS, data);
+    assert(encodeAbiParameters(TERMS, [t]).toLowerCase() === data.toLowerCase(), "Non-canonical compliance terms");
+    return { ...t, listId: t.listId.toLowerCase() };
+}
+/**
+ * A compliance-guarded member's advisory pool terms: fail closed, BEFORE_SWAP, and the admission's gas, which must
+ * clear the guard's 150,000 floor.
+ */
+export function complianceAdvisoryTerms(admission) {
+    checkAdmission(admission);
+    assert(admission.kind === ADMISSION_KIND.ADVISORY && (admission.phaseMask & PHASE.BEFORE_SWAP) !== 0, "Guard admission needs BEFORE_SWAP");
+    assert(admission.gasLimit >= COMPLIANCE_MIN_ADVISORY_GAS, "Guard admission gas below 150000");
+    return { advisoryGasLimit: admission.gasLimit, advisoryPhases: PHASE.BEFORE_SWAP, advisoryFailOpen: false };
+}