hookr-sdk 0.2.1 → 1.1.0

package/dist/core/pair.d.ts

@@ -0,0 +1,64 @@
+import { type Hex } from "viem";
+import { type Address, type Call, type DeploymentManifest, type Hash } from "./schema.js";
+import { type PoolKey } from "./wallet.js";
+/** IHookrPairRoot.Params: every value is immutable for the life of the pool. */
+export interface PairRootParams {
+    currency0: Address;
+    currency1: Address;
+    tickSpacing: number;
+    baseLpFeePips: number;
+    /** Ceiling on every fee the root returns; at least base plus advisory cap. */
+    maxLpFeePips: number;
+    /** Zero for a fixed-fee pool. */
+    advisory: Address;
+    advisoryCapPips: number;
+    advisoryGasLimit: number;
+    /** On advisory failure, true charges the cap and false reverts the swap. */
+    advisoryFailOpen: boolean;
+}
+/** Low 14 address bits of every pair root: BEFORE_INITIALIZE | BEFORE_SWAP. */
+export declare const PAIR_ROOT_FLAGS: 8320;
+/** Leading address byte the salt miner refuses: the prefix that opts a hook out of Uniswap routing. */
+export declare const PAIR_ROOT_REFUSED_PREFIX: 145;
+/** Refuses Params the HookrPairRoot constructor would refuse (the checks that do not read chain state). */
+export declare function checkPairRootParams(p: PairRootParams): PairRootParams;
+/** The one pool a pair root at `root` serves. */
+export declare function pairRootPoolKey(root: Address, p: PairRootParams): PoolKey;
+/** HookrRootFactory.deploySalt: keccak256(abi.encode(deployer, salt)). The CREATE2 salt binds the caller. */
+export declare function pairRootDeploySalt(deployer: Address, salt: Hash): Hash;
+/**
+ * CREATE2 init code of a pair root: HookrPairRoot creation code followed by abi.encode(poolManager, registry,
+ * params). `creationCode` must be the reviewed build the factory was deployed with; compare
+ * keccak256(creationCode) with the factory's `pairRootCreationCodeHash()`.
+ */
+export declare function pairRootInitCode(creationCode: Hex, poolManager: Address, registry: Address, p: PairRootParams): Hex;
+/** keccak256 of `pairRootInitCode`: the value HookrRootFactory.initCodeHash(params) returns. */
+export declare function pairRootInitCodeHash(creationCode: Hex, poolManager: Address, registry: Address, p: PairRootParams): Hash;
+/** HookrRootFactory.computeAddress for a known init code hash. */
+export declare function pairRootAddress(factory: Address, deployer: Address, salt: Hash, initCodeHash: Hash): Address;
+/** Whether a root address carries exactly the pair root flags and does not start with the refused prefix. */
+export declare function isPairRootAddress(root: Address): boolean;
+/**
+ * Lowest salt at or above `start` for which `factory` deploys `deployer`'s root at an address carrying exactly
+ * the pair root flags (0x2080) and not starting with the refused prefix (0x91). Salts are uint256 counters as
+ * bytes32, so the result matches script/HookrPairRootSalt.s.sol. Runs locally; `limit` bounds the search (about
+ * 16,500 tries are expected per hit).
+ */
+export declare function minePairRootSalt(p: {
+    factory: Address;
+    deployer: Address;
+    initCodeHash: Hash;
+    start?: bigint;
+    limit?: bigint;
+}): {
+    salt: Hash;
+    root: Address;
+    tries: bigint;
+};
+/**
+ * HookrRootFactory.deploy: deploys the pair root under `salt` (mined for the caller, `minePairRootSalt`),
+ * registers it, binds its pool in the advisory with `advisoryData` and initializes the pool at `sqrtPriceX96`.
+ * The advisory, when set, must be a pinned HookrFeeAdvisory or HookrSessionAdvisory; build `advisoryData` with
+ * `encodeBindPairData`. Without an advisory `advisoryData` must be "0x".
+ */
+export declare function buildPairRootDeploy(m: DeploymentManifest, salt: Hash, p: PairRootParams, sqrtPriceX96: bigint, advisoryData?: Hex): Call;

package/dist/core/pair.js

@@ -0,0 +1,136 @@
+import { concat, encodeAbiParameters, hexToBytes, keccak256, bytesToHex } from "viem";
+import { ARTIFACT_ABIS, RELEASE_CONSTANTS } from "./generated.js";
+import { address, assert, hash, uint, ZERO, } from "./schema.js";
+import { buildCall } from "./wallet.js";
+const factoryAbi = ARTIFACT_ABIS.HookrRootFactory;
+/** Low 14 address bits of every pair root: BEFORE_INITIALIZE | BEFORE_SWAP. */
+export const PAIR_ROOT_FLAGS = RELEASE_CONSTANTS.PAIR_ROOT_PERMISSION_FLAGS;
+/** Leading address byte the salt miner refuses: the prefix that opts a hook out of Uniswap routing. */
+export const PAIR_ROOT_REFUSED_PREFIX = RELEASE_CONSTANTS.PAIR_ROOT_REFUSED_PREFIX;
+const FLAG_MASK = 0x3fff;
+const DYNAMIC_FEE = 0x800000;
+const MIN_SQRT_PRICE = 4295128739n;
+const MAX_SQRT_PRICE = 1461446703485210103287273052203988822378723970342n;
+/** The Params tuple, as the factory ABI declares it. */
+function paramsParameter() {
+    const deploy = factoryAbi.find((e) => e.type === "function" && e.name === "deploy");
+    assert(deploy && deploy.type === "function", "HookrRootFactory ABI lacks deploy");
+    const p = deploy.inputs.find((i) => i.name === "params");
+    assert(p, "HookrRootFactory.deploy lacks params");
+    return p;
+}
+/** Refuses Params the HookrPairRoot constructor would refuse (the checks that do not read chain state). */
+export function checkPairRootParams(p) {
+    const c0 = address(p.currency0, true);
+    const c1 = address(p.currency1);
+    assert(BigInt(c0) < BigInt(c1), "Unsorted pool currencies");
+    assert(Number.isInteger(p.tickSpacing) && p.tickSpacing >= 1 && p.tickSpacing <= 32767, "Invalid tick spacing");
+    for (const [v, label] of [
+        [p.baseLpFeePips, "base fee"],
+        [p.maxLpFeePips, "max fee"],
+        [p.advisoryCapPips, "advisory cap"],
+    ])
+        assert(Number.isInteger(v) && v >= 0 && v < 2 ** 24, `Invalid ${label}`);
+    assert(p.maxLpFeePips <= RELEASE_CONSTANTS.PAIR_ROOT_MAX_LP_FEE_PIPS, "Max fee above 600000 pips");
+    assert(p.baseLpFeePips + p.advisoryCapPips <= p.maxLpFeePips, "Base fee plus advisory cap above max fee");
+    assert(Number.isInteger(p.advisoryGasLimit) && p.advisoryGasLimit >= 0, "Invalid advisory gas");
+    const advisory = address(p.advisory, true);
+    if (advisory === ZERO) {
+        assert(p.advisoryCapPips === 0 && p.advisoryGasLimit === 0 && !p.advisoryFailOpen, "Advisory terms without an advisory");
+    }
+    else {
+        assert(p.advisoryCapPips > 0, "Advisory needs a cap");
+        assert(p.advisoryGasLimit > 0 && p.advisoryGasLimit <= RELEASE_CONSTANTS.PAIR_ROOT_MAX_ADVISORY_GAS, "Advisory gas outside (0, 500000]");
+    }
+    return { ...p, currency0: c0, currency1: c1, advisory };
+}
+/** The one pool a pair root at `root` serves. */
+export function pairRootPoolKey(root, p) {
+    return {
+        currency0: address(p.currency0, true),
+        currency1: address(p.currency1),
+        fee: DYNAMIC_FEE,
+        tickSpacing: p.tickSpacing,
+        hooks: address(root),
+    };
+}
+/** HookrRootFactory.deploySalt: keccak256(abi.encode(deployer, salt)). The CREATE2 salt binds the caller. */
+export function pairRootDeploySalt(deployer, salt) {
+    return keccak256(encodeAbiParameters([{ type: "address" }, { type: "bytes32" }], [address(deployer), hash(salt)]));
+}
+/**
+ * CREATE2 init code of a pair root: HookrPairRoot creation code followed by abi.encode(poolManager, registry,
+ * params). `creationCode` must be the reviewed build the factory was deployed with; compare
+ * keccak256(creationCode) with the factory's `pairRootCreationCodeHash()`.
+ */
+export function pairRootInitCode(creationCode, poolManager, registry, p) {
+    const params = checkPairRootParams(p);
+    return concat([
+        creationCode,
+        encodeAbiParameters([{ type: "address" }, { type: "address" }, paramsParameter()], [address(poolManager), address(registry), params]),
+    ]);
+}
+/** keccak256 of `pairRootInitCode`: the value HookrRootFactory.initCodeHash(params) returns. */
+export function pairRootInitCodeHash(creationCode, poolManager, registry, p) {
+    return keccak256(pairRootInitCode(creationCode, poolManager, registry, p));
+}
+/** HookrRootFactory.computeAddress for a known init code hash. */
+export function pairRootAddress(factory, deployer, salt, initCodeHash) {
+    const digest = keccak256(concat(["0xff", address(factory), pairRootDeploySalt(deployer, salt), hash(initCodeHash)]));
+    return `0x${digest.slice(26)}`;
+}
+/** Whether a root address carries exactly the pair root flags and does not start with the refused prefix. */
+export function isPairRootAddress(root) {
+    const a = address(root);
+    return (Number(BigInt(a) & BigInt(FLAG_MASK)) === PAIR_ROOT_FLAGS &&
+        parseInt(a.slice(2, 4), 16) !== PAIR_ROOT_REFUSED_PREFIX);
+}
+/**
+ * Lowest salt at or above `start` for which `factory` deploys `deployer`'s root at an address carrying exactly
+ * the pair root flags (0x2080) and not starting with the refused prefix (0x91). Salts are uint256 counters as
+ * bytes32, so the result matches script/HookrPairRootSalt.s.sol. Runs locally; `limit` bounds the search (about
+ * 16,500 tries are expected per hit).
+ */
+export function minePairRootSalt(p) {
+    const start = uint(p.start ?? 0n);
+    const limit = uint(p.limit ?? 10000000n);
+    const inner = new Uint8Array(64);
+    inner.set(hexToBytes(address(p.deployer)), 12);
+    const outer = new Uint8Array(85);
+    outer[0] = 0xff;
+    outer.set(hexToBytes(address(p.factory)), 1);
+    outer.set(hexToBytes(hash(p.initCodeHash)), 53);
+    const saltBytes = inner.subarray(32);
+    for (let tries = 0n; tries < limit; tries++) {
+        let i = start + tries;
+        assert(i < 1n << 256n, "Salt space exhausted");
+        for (let b = 31; b >= 0; b--) {
+            saltBytes[b] = Number(i & 0xffn);
+            i >>= 8n;
+        }
+        outer.set(keccak256(inner, "bytes"), 21);
+        const h = keccak256(outer, "bytes");
+        if ((((h[30] << 8) | h[31]) & FLAG_MASK) === PAIR_ROOT_FLAGS && h[12] !== PAIR_ROOT_REFUSED_PREFIX) {
+            return { salt: bytesToHex(saltBytes), root: bytesToHex(h.subarray(12)), tries: tries + 1n };
+        }
+    }
+    throw new Error("No pair root salt within the search limit");
+}
+/**
+ * HookrRootFactory.deploy: deploys the pair root under `salt` (mined for the caller, `minePairRootSalt`),
+ * registers it, binds its pool in the advisory with `advisoryData` and initializes the pool at `sqrtPriceX96`.
+ * The advisory, when set, must be a pinned HookrFeeAdvisory or HookrSessionAdvisory; build `advisoryData` with
+ * `encodeBindPairData`. Without an advisory `advisoryData` must be "0x".
+ */
+export function buildPairRootDeploy(m, salt, p, sqrtPriceX96, advisoryData = "0x") {
+    const params = checkPairRootParams(p);
+    hash(salt);
+    const price = uint(sqrtPriceX96, 160);
+    assert(price >= MIN_SQRT_PRICE && price < MAX_SQRT_PRICE, "sqrtPriceX96 out of range");
+    assert(/^0x([\da-fA-F]{2})*$/.test(advisoryData), "Invalid advisory data");
+    if (params.advisory === ZERO)
+        assert(advisoryData === "0x", "Advisory data without an advisory");
+    else
+        assert(m.contracts.some((c) => (c.role === "feeAdvisory" || c.role === "sessionAdvisory") && c.address === params.advisory), "Unqualified advisory");
+    return buildCall(m, "rootFactory", factoryAbi, "deploy", [salt, params, price, advisoryData]);
+}

package/dist/core/params.d.ts

@@ -0,0 +1,415 @@
+import { type Hex } from "viem";
+import { type FeeAdvisoryConfig, type FeeAdvisoryRoot, type SessionSchedule, type SessionTiers } from "./advisories.js";
+import { type PairRootParams } from "./pair.js";
+import { type Admission } from "./registry.js";
+import { type Caps, type RulesConfig, type RulesKnobs } from "./rules.js";
+import { type Address, type Hash } from "./schema.js";
+/**
+ * Creator knobs of every Hookr rule, one manifest per rule. The launch wizard draws its inputs from `RULE_PARAMS` and
+ * the checked encoders below refuse any value outside the same bounds, so the bounds a creator sees are the ones the
+ * contracts enforce at bind. Bounds that depend on other knobs are functions of the whole configuration.
+ */
+/** Unit of a knob's raw value. Pips are 1e-6 and basis points 1e-4; `raw` is an integer in the asset's own units. */
+export type ParamUnit = "pips" | "bps" | "blocks" | "seconds" | "raw" | "ticks" | "gas" | "bool" | "mask" | "address" | "bytes32";
+/** Where a knob lands: the launch or deploy call, the Rules bind data, an advisory's bind data, or a KOTH config. */
+export type ParamWhere = "launch" | "bind" | "advisoryData" | "kothConfig";
+/** A knob value. Booleans read as 0 and 1, addresses and bytes32 values as unsigned integers. */
+export type ParamValue = number | bigint | boolean | string;
+/** A configuration under edit: knob name to value. */
+export type ParamConfig = Readonly<Record<string, ParamValue>>;
+/** Chain and pool facts the bounds and defaults read. Every field is optional; a knob that needs one says so. */
+export interface ParamContext {
+    /** Current block.number. Without it the Anti-Snipe window is bounded only by its type. */
+    blockNumber?: bigint;
+    /** Measured parent block time in seconds, used to convert the default guard length. Default 12. */
+    blockTimeSeconds?: number;
+    /**
+     * HookrRules.minProtocolShareBps of the Rules the pool binds to: read it from the deployed Rules
+     * (`encodeMinProtocolShareCall`, `decodeMinProtocolShareBps`) or take the release's reviewed value (its deployment
+     * configuration's `rulesMinProtocolShareBps`, read back from the Rules at bootstrap). An integer from 0 to 5,000;
+     * default 0.
+     */
+    minProtocolShareBps?: number;
+    /**
+     * The governed rule-share floor of the treasury the Rules pay, read at the launch block (`encodeFeeTermsCall`,
+     * `decodeFeeTerms`): the protocol share binds at no less than the larger of it and minProtocolShareBps. 0 to 5,000;
+     * default 0, the treasury's starting value.
+     */
+    ruleShareFloorBps?: number;
+    /**
+     * The integrator the launch goes through, pre-filled as the `integrator` knob (default zero, none). It must be on
+     * the treasury's integrator list when the pool binds (`integrators`).
+     */
+    integrator?: Address;
+    /**
+     * The treasury's integrator list as read on chain: lowercase address to rate (`feeTerms(integrator)`). With it a
+     * nonzero integrator knob must be listed at 1 to 5,000. Without it the SDK cannot see the list offline and accepts
+     * any address; HookrRules then refuses one off the list at bind (`UnknownIntegrator`), so read it before signing.
+     */
+    integrators?: Readonly<Record<string, number>>;
+    /**
+     * The accounts HookrRules refuses as integrator whatever the treasury answers (r26, `bindRefusedIntegrators`: the
+     * Rules, their root, their protocol recipient, the PoolManager and their HookrRecapture module). With it the checked
+     * encoder refuses such an integrator knob offline; HookrRules refuses it at bind either way.
+     */
+    refusedIntegrators?: readonly Address[];
+    /**
+     * The accounts HookrRules refuses as the royalty recipient (r31, `bindRefusedRoyaltyRecipients`: the Rules, their
+     * root, the PoolManager and their HookrRecapture module). With it the checked encoder refuses such a `royaltyTo`
+     * offline; HookrRules refuses it at bind either way.
+     */
+    refusedRoyaltyRecipients?: readonly Address[];
+    /**
+     * The Hookr minimum the member binds, in pips: `bindMinFeePips(subject, feeTerms(..).minFeePips, terms)`, the
+     * treasury's minimum for this pool (read at the launch block with `encodeFeeTermsCall(integrator, false, poolId)`)
+     * when the subject is a Hookr token (a new token always is one), the member binds no arb recapture and its rules earn
+     * Hookr no share (r31), zero for any other pool or a Rules paying an address without code. The derived caps
+     * (`rulesPoolTerms`) then admit royalty + minimum, which HookrRules requires at bind: a launch whose caps do not
+     * admit it reverts. 0 to 10,000; default 0.
+     */
+    minFeePips?: number;
+    /**
+     * The member's quote-side seed in raw quote units. The default buy cap is 0.5% of the launch's quote depth: the
+     * virtual quote reserve at the opening price when `launchLiquidity`, `launchSqrtPriceX96` and `quoteIsCurrency0` are
+     * all given, otherwise 0.5% of this seed (zero without either).
+     */
+    quoteSeed?: bigint;
+    /**
+     * The member's launch liquidity (`HookrLauncher.Member.liquidity`). The Launcher binds a dynamic fee member with
+     * minLiquidity = liquidity / DYNAMIC_FEE_LIQUIDITY_DIVISOR (100), at least 1 and at most 2^96 - 1; with it the
+     * minLiquidity knob is pinned to that value. Without it the knob takes any value HookrRules binds.
+     */
+    launchLiquidity?: bigint;
+    /** The member's opening price (`HookrLauncher.Member.sqrtPriceX96`), for the default buy cap's quote depth. */
+    launchSqrtPriceX96?: bigint;
+    /**
+     * Whether the member's quote is the pool's currency0. A new token's address, and so the side, is known only when the
+     * launch is signed: derive the default again then.
+     */
+    quoteIsCurrency0?: boolean;
+    /** Royalty recipient offered when a creator turns royalty on. */
+    creator?: Address;
+    /** Fee advisory: the largest cap its Config may take (`feeAdvisoryLimit`, or a pair root's advisoryCapPips). */
+    advisoryLimit?: number;
+    /** Session tiers: the fee Config cap. Session advisory: its admitted cap, or a pair root's advisoryCapPips. */
+    tierCap?: number;
+    /**
+     * Pair root: the chosen advisory's factory admission (`admission(factory, advisory)`). Its `failOpen`, `feeOnly`
+     * and `maxQuoteTakePips` bound the root's fail-open flag (HookrRootFactory); omitted, they read as fail closed,
+     * not fee-only and no quote take.
+     */
+    pairAdmission?: {
+        maxLpFeePips: number;
+        gasLimit: number;
+        failOpen?: boolean;
+        feeOnly?: boolean;
+        maxQuoteTakePips?: number;
+    };
+    /** Pair root: which advisory the root names, for its gas floor. */
+    pairAdvisoryKind?: "fee" | "feeTiered" | "session";
+    /** Compliance guard: the pool's caps.maxSubjectTakeBps (RESTRICTED_SUBJECT needs zero). */
+    subjectTakeBps?: number;
+    /** Compliance guard: whether `listId` exists in HookrCompliance. Omitted: not checked. */
+    listExists?: boolean;
+    /**
+     * Dev buy: the Anti-Snipe terms of every family member, in member order (`HookrLauncher.Member.rules`). An unguarded
+     * member (guardEndBlock zero) takes a dev buy with no Snipe and no cap (r31); a guarded one must be guarded past
+     * `blockNumber`, charge a Snipe and cap guarded buys at `quoteIn` or more. Omitted: no member can take a dev buy.
+     */
+    launchMembers?: readonly DevBuyMemberTerms[];
+    /** Dev buy: whether the launch creates its token (`Token.existing` zero). A dev buy needs a new token. */
+    newToken?: boolean;
+}
+/** The Anti-Snipe terms of a launch member that decide whether it can take the dev buy. */
+export type DevBuyMemberTerms = Pick<RulesConfig, "guardEndBlock" | "snipeTaxPips" | "maxBuyQuoteAmount">;
+/** A bound: fixed, or computed from the configuration under edit and the context. */
+export type ParamBound = number | bigint | ((cfg: ParamConfig, ctx: ParamContext) => number | bigint);
+/** One bit of a `mask` knob, shown as a named checkbox. */
+export interface ParamOption {
+    bit: number;
+    name: string;
+    /** Not a free toggle: derived by the SDK from other facts. */
+    hidden?: boolean;
+    disclose?: string;
+}
+/** One creator knob. */
+export interface RuleParam {
+    /** Field name in the bind struct, launch params or pool config. */
+    name: string;
+    /** Solidity type of the field. */
+    type: string;
+    unit: ParamUnit;
+    min: ParamBound;
+    max: ParamBound;
+    default: ParamValue | ((ctx: ParamContext, cfg: ParamConfig) => ParamValue);
+    where: ParamWhere;
+    /** Knobs whose value moves this knob's bounds. */
+    dependsOn?: readonly string[];
+    /** Step between accepted values, counted from zero. Default 1. */
+    grid?: number;
+    /** Zero is accepted outside [min, max]: the rule is off. */
+    zeroIsOff?: boolean;
+    /** Set by the SDK, not shown to creators. */
+    hidden?: boolean;
+    /** What the wizard must tell the creator next to this knob. */
+    disclose?: string;
+    /** Tighter input limits for the wizard where the contract has no bound of its own. Never used to refuse. */
+    ui?: {
+        min: number;
+        max: number;
+    };
+    /** Named bits of a `mask` knob. */
+    options?: readonly ParamOption[];
+}
+/** Resolved bounds of one knob for one configuration. */
+export interface ParamBounds {
+    min: bigint;
+    max: bigint;
+    grid: bigint;
+    zeroIsOff: boolean;
+}
+/** A knob value as an unsigned integer. Refuses fractions, negatives and malformed hex. */
+export declare function paramValue(v: ParamValue | undefined): bigint;
+/** The default per-block guarded buy cap, in basis points of the launch's quote depth (`quoteDepth`). */
+export declare 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 declare function quoteDepth(ctx: Pick<ParamContext, "quoteSeed" | "launchLiquidity" | "launchSqrtPriceX96" | "quoteIsCurrency0">): bigint | undefined;
+/** The protocol share a launch starts with: 2,000 bps (20%), or the Rules minimum when that is higher. */
+export declare const DEFAULT_PROTOCOL_SHARE_BPS = 2000;
+/** HookrComplianceGuard flag: also check the recipient. */
+export declare const COMPLIANCE_CHECK_BENEFICIARY = 1;
+/** HookrComplianceGuard flag: sellers need a credential too. */
+export declare const COMPLIANCE_KYC_ON_SELL = 2;
+/** HookrComplianceGuard flag: sells stop too while the sanctions source is down. */
+export declare const COMPLIANCE_HALT_SELLS_WHEN_SOURCE_DOWN = 4;
+/** HookrComplianceGuard flag: the subject enforces transfer restrictions; needs a zero subject take. */
+export declare const COMPLIANCE_RESTRICTED_SUBJECT = 8;
+/** HookrComplianceGuard flag: accept curated-router swaps; needs RESTRICTED_SUBJECT or no list. */
+export declare const COMPLIANCE_ACCEPT_CURATED = 16;
+/** HookrComplianceGuard flag: permitted senders other than the launcher may add liquidity. */
+export declare const COMPLIANCE_DIRECT_LP_IF_PERMITTED = 32;
+/** Every HookrComplianceGuard flag. */
+export declare const COMPLIANCE_ALL_FLAGS = 63;
+/** HookrComplianceGuard.MIN_ADVISORY_GAS. */
+export declare const COMPLIANCE_MIN_ADVISORY_GAS = 150000;
+/** HookrLauncher.MAX_DEV_BUY_BPS: the most of the supply, in basis points, a creator holds when a dev-buy launch returns. */
+export declare const MAX_DEV_BUY_BPS: number;
+/** HookrLauncher.MAX_DEV_BUY_LOCK_BLOCKS: the longest DevBuy.lockBlocks, 365 days of 12-second parent blocks. */
+export declare const MAX_DEV_BUY_LOCK_BLOCKS: number;
+/** Largest DevBuy.quoteIn the Launcher swaps: it negates it into an int256 amountSpecified bounded by int128. */
+export declare const MAX_DEV_BUY_QUOTE_IN: bigint;
+/**
+ * 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 declare const DEFAULT_DEV_BUY_LOCK_SECONDS: number;
+/** 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 declare function devBuyLockBlocksFor(seconds: number, blockTimeSeconds?: number): number;
+/**
+ * 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 declare function devBuyMemberRefusal(r: DevBuyMemberTerms | undefined, quoteIn: bigint, blockNumber?: bigint): string | null;
+/**
+ * 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 declare const RULE_PARAMS: {
+    readonly pool: readonly RuleParam[];
+    readonly antiSnipe: readonly RuleParam[];
+    readonly dynamicFee: readonly RuleParam[];
+    readonly autoBurn: readonly RuleParam[];
+    readonly lpRewards: readonly RuleParam[];
+    readonly royalty: readonly RuleParam[];
+    readonly protocolShare: readonly RuleParam[];
+    readonly feeAdvisory: readonly RuleParam[];
+    readonly sessionTiers: RuleParam[];
+    readonly sessionAdvisory: RuleParam[];
+    readonly pairRoot: readonly RuleParam[];
+    readonly compliance: readonly RuleParam[];
+    readonly devBuy: readonly RuleParam[];
+    readonly family: readonly RuleParam[];
+};
+export type RuleName = keyof typeof RULE_PARAMS;
+/** The rules whose knobs make up a HookrRoot launch member: its pool knobs and one RulesConfig. */
+export declare const RULES_MEMBER_RULES: readonly ["pool", "antiSnipe", "dynamicFee", "autoBurn", "lpRewards", "royalty", "protocolShare"];
+/** Resolves one knob's bounds for `cfg`. */
+export declare function paramBounds(p: RuleParam, cfg: ParamConfig, ctx?: ParamContext): ParamBounds;
+/** Refuses a knob value outside its bounds or off its grid. */
+export declare function checkParam(rule: string, p: RuleParam, cfg: ParamConfig, ctx?: ParamContext): void;
+/** Every knob of `rule` outside its bounds in `cfg`, one message each; empty when all are inside. */
+export declare function ruleParamErrors(rule: RuleName, cfg: ParamConfig, ctx?: ParamContext): string[];
+/** Refuses a configuration with any knob of `rule` outside its bounds, naming every such knob. */
+export declare function checkRuleParams(rule: RuleName, cfg: ParamConfig, ctx?: ParamContext): void;
+/** The default configuration of `rule`, knob by knob in manifest order; `base` fixes knobs already chosen. */
+export declare function defaultRuleParams(rule: RuleName, ctx?: ParamContext, base?: ParamConfig): Record<string, ParamValue>;
+/** Parent blocks covering `seconds` at the measured block time, rounded up. */
+export declare function guardBlocksFor(seconds: number, blockTimeSeconds?: number): bigint;
+/**
+ * A HookrRoot launch member's creator knobs: its pool terms, its Rules configuration and its Rules knobs (r31): with
+ * dynamic fees the minLiquidity and the tempo bound after the configuration, and the Snipe curve (all zero without
+ * them). `dynamicFeeLiquidityDivisor` is launchFamily's MemberKnobs divisor (zero: DYNAMIC_FEE_LIQUIDITY_DIVISOR).
+ */
+export interface RulesLaunch {
+    baseLpFeePips: number;
+    tickSpacing: number;
+    rules: RulesConfig;
+    minLiquidity: bigint;
+    windowSeconds: number;
+    resetSeconds: number;
+    carryBps: number;
+    moveTicks: number;
+    snipeCurve: number;
+    dynamicFeeLiquidityDivisor: number;
+}
+/** The RulesKnobs a launch member binds: its minLiquidity, its tempo and its Snipe curve. */
+export declare function rulesKnobsOf(l: RulesLaunch): RulesKnobs;
+/** Every knob of a HookrRoot launch member at its default. */
+export declare function defaultRulesLaunch(ctx?: ParamContext): RulesLaunch;
+/**
+ * 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 declare function rulesLaunchOf(cfg: ParamConfig): RulesLaunch;
+/**
+ * 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 declare function encodeRulesBind(l: RulesLaunch, ctx?: ParamContext & {
+    liquidityOwner?: Address;
+}): Hex;
+/** Which advisory a HookrRoot member binds, for its gas floor and phases. */
+export type RootAdvisoryKind = "fee" | "feeTiered" | "session" | "compliance";
+/**
+ * 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 declare const ROOT_ADVISORY_MIN_GAS: Readonly<Record<RootAdvisoryKind, number>>;
+/** A HookrRoot member's derived pool terms: never typed by a creator. */
+export interface PoolTerms {
+    rulesData: Hex;
+    /** Tightest PoolConfig.caps HookrRules accepts, plus the advisory's admitted maximum. */
+    caps: Caps;
+    rulesGasLimit: number;
+    /** The advisory admission's gas limit: HookrRoot requires exactly it. Zero without an advisory. */
+    advisoryGasLimit: number;
+    advisoryPhases: number;
+}
+/**
+ * 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 declare function rulesPoolTerms(l: RulesLaunch, ctx: ParamContext & {
+    liquidityOwner?: Address;
+}, rulesAdmission: Admission, advisory?: {
+    admission: Admission;
+    kind: RootAdvisoryKind;
+    phases?: number;
+}): PoolTerms;
+/**
+ * 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 declare function feeAdvisoryLimit(l: RulesLaunch, poolCaps: Caps, admissionCap: number): number;
+/** Which side each fee premium prices: premium0 is zeroForOne, a buy when the quote is currency0. */
+export declare function feePremiumSides(quoteIsCurrency0: boolean): {
+    premium0: "buy" | "sell";
+    premium1: "buy" | "sell";
+};
+/**
+ * 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 declare function encodeFeeAdvisoryParams(c: FeeAdvisoryConfig, ctx: ParamContext, gasLimit: number, tiers?: SessionTiers, root?: FeeAdvisoryRoot): Hex;
+/** Checked session-advisory bind data: the Schedule against the manifest with `ctx.tierCap`. */
+export declare function encodeSessionScheduleParams(s: SessionSchedule, ctx: ParamContext): Hex;
+/** A pair root's creator knobs. Pool currencies are the pair; the hidden knobs are derived when omitted. */
+export interface PairRootKnobs {
+    currency0: Address;
+    currency1: Address;
+    tickSpacing: number;
+    baseLpFeePips: number;
+    advisory: Address;
+    advisoryCapPips: number;
+    advisoryFailOpen?: boolean;
+    maxLpFeePips?: number;
+    advisoryGasLimit?: number;
+}
+/**
+ * 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 declare function pairRootParamsFor(k: PairRootKnobs, ctx?: ParamContext, admission?: {
+    admission: Admission;
+    advisoryCodeHash: Hash;
+}): PairRootParams;
+/** IHookrComplianceGuard.Terms: the guard's bind data. */
+export interface ComplianceTerms {
+    listId: Hash;
+    requireAll: number;
+    blockAny: number;
+    flags: number;
+}
+/**
+ * Compliance flags from named options. RESTRICTED_SUBJECT is derived from the subject token, never chosen.
+ */
+export declare function complianceFlags(o: {
+    checkBeneficiary?: boolean;
+    kycOnSell?: boolean;
+    haltSellsWhenSourceDown?: boolean;
+    acceptCurated?: boolean;
+    directLpIfPermitted?: boolean;
+    restrictedSubject: boolean;
+}): number;
+/**
+ * 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 declare function checkComplianceTerms(t: ComplianceTerms, ctx?: ParamContext): void;
+/** Checked compliance terms as the guard's canonical 128-byte bind data. */
+export declare function encodeComplianceTerms(t: ComplianceTerms, ctx?: ParamContext): Hex;
+/** Decodes compliance bind data, refusing any size or encoding the guard refuses. */
+export declare function decodeComplianceTerms(data: Hex): ComplianceTerms;
+/**
+ * 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 declare function complianceAdvisoryTerms(admission: Admission): {
+    advisoryGasLimit: number;
+    advisoryPhases: number;
+    advisoryFailOpen: false;
+};