hookr-sdk 0.2.1 → 1.0.0

package/dist/core/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./schema.js";
+export * from "./abi.js";
+export * from "./generated.js";
+export * from "./proofs.js";
+export * from "./wallet.js";
+export * from "./client.js";
+export * from "./referrals.js";
+export * from "./policies.js";
+export * from "./rules.js";
+export * from "./registry.js";
+export * from "./pair.js";
+export * from "./advisories.js";
+export * from "./vault.js";
+export * from "./params.js";
+export * from "./launch.js";
+export * from "./quotes.js";
+export * from "./stocks.generated.js";

package/dist/core/index.js

@@ -0,0 +1,17 @@
+export * from "./schema.js";
+export * from "./abi.js";
+export * from "./generated.js";
+export * from "./proofs.js";
+export * from "./wallet.js";
+export * from "./client.js";
+export * from "./referrals.js";
+export * from "./policies.js";
+export * from "./rules.js";
+export * from "./registry.js";
+export * from "./pair.js";
+export * from "./advisories.js";
+export * from "./vault.js";
+export * from "./params.js";
+export * from "./launch.js";
+export * from "./quotes.js";
+export * from "./stocks.generated.js";

package/dist/core/launch.d.ts

@@ -0,0 +1,200 @@
+import { type Hex } from "viem";
+import { type ParamContext } from "./params.js";
+import { type MemberKnobs, type RulesKnobs } from "./rules.js";
+import { type Address, type Call, type DeploymentManifest, type Hash } from "./schema.js";
+import { type PoolKey } from "./wallet.js";
+/**
+ * HookrLauncher.DevBuy: the optional first buy of a new-token launch, on member `member`'s pool, made right after
+ * that member's liquidity add and delivered to the launch caller. `quoteIn` is the exact quote spent, `minSubjectOut`
+ * the least subject received net of Auto Burn, and `lockBlocks` keeps the family's principal locked at least that many
+ * parent blocks past the launch block (fees stay collectable). Its knobs and bounds are `RULE_PARAMS.devBuy`.
+ */
+export interface DevBuy {
+    member: number;
+    quoteIn: bigint;
+    minSubjectOut: bigint;
+    lockBlocks: number;
+}
+/** HookrLauncher.Token, as buildLaunch takes it. */
+export interface LaunchToken {
+    existing: Address;
+    name: string;
+    symbol: string;
+    supply: bigint;
+    salt: Hash;
+}
+/** Facts a dev-buy launch is checked against beyond its arguments. */
+export interface DevBuyOptions {
+    /** block.number the launch is expected to land in; the member's guard must end after it. */
+    blockNumber?: bigint;
+    /**
+     * The new token's address (`buildPredictToken`). With it the builder knows each member's subject side and refuses a
+     * launch whose unplaced supply alone is above the 5% the creator may hold.
+     */
+    subject?: Address;
+}
+/** Slippage `quoteDevBuy` takes off the quoted subjectOut by default: 1%. */
+export declare const DEFAULT_DEV_BUY_SLIPPAGE_BPS = 100;
+/** The minSubjectOut for a quoted subjectOut: `slippageBps` (0 to 9,999) off it, and never below 1. */
+export declare function devBuyMinSubjectOut(subjectOut: bigint, slippageBps?: number): bigint;
+/** The most subject the creator may hold when a dev-buy launch returns: floor(supply * 500 / 10,000), as the Launcher. */
+export declare function devBuyHoldCap(supply: bigint): bigint;
+/**
+ * The least unplaced supply the Launcher refunds the creator: the supply less every member's subject maximum. The
+ * Launcher refunds supply less the subject the bands actually took, so the refund is at least this.
+ */
+export declare function unplacedSubjectFloor(token: LaunchToken, members: readonly Record<string, unknown>[], subject: Address): bigint;
+/** The dev-buy knob context of a launch: every member's Anti-Snipe terms and whether its token is new. */
+export declare function devBuyContext(token: LaunchToken, members: readonly Record<string, unknown>[], blockNumber?: bigint): ParamContext;
+/**
+ * Refuses a dev buy HookrLauncher._checkBuy refuses before it swaps (InvalidDevBuy): an existing token, a zero quoteIn
+ * or minSubjectOut, an unknown member, a quoteIn above int128, a lock above MAX_DEV_BUY_LOCK_BLOCKS, or a guarded
+ * member whose guard ends by `blockNumber`, without a Snipe or with a per-block cap below quoteIn (an unguarded member
+ * takes any dev buy, r31). Then checks the knobs against `RULE_PARAMS.devBuy`.
+ */
+export declare function checkDevBuy(buy: DevBuy, token: LaunchToken, members: readonly Record<string, unknown>[], blockNumber?: bigint): void;
+/**
+ * launchAdvised with a dev buy (HookrLauncher.launchWithBuy). `nativeBudget` is the native members' liquidity maxima,
+ * as for buildLaunch; the call's value adds `buy.quoteIn` when the dev-buy member's quote is native, and the launch fee
+ * (`launchFee`, read at the launch block). An ERC-20 quote is pulled from the caller with that member's budget, so
+ * approve the Launcher for both. The Launcher delivers the dev-bought subject to the caller and reverts DevBuyAboveCap
+ * when the caller would hold more than 5% of the supply, dev-bought and unplaced together. Use `quoteDevBuy` to set
+ * `minSubjectOut`.
+ */
+export declare function buildLaunchWithBuy(m: DeploymentManifest, token: LaunchToken, root: Address, members: readonly Record<string, unknown>[], advisoryConfigs: readonly Hash[], buy: DevBuy, nativeBudget: bigint, deadline: bigint, launchFee: bigint, opts?: DevBuyOptions): Call;
+/** An eth_call executor: runs `tx` at the chosen block and returns the call's return data. It throws on a revert. */
+export type EthCall = (tx: {
+    from: Address;
+    to: Address;
+    data: Hex;
+    value: bigint;
+}) => Promise<Hex>;
+/** A quoted dev-buy launch. `call` is the launchWithBuy to sign, with `minSubjectOut` set. */
+export interface DevBuyQuote {
+    subjectOut: bigint;
+    minSubjectOut: bigint;
+    call: Call;
+}
+/**
+ * Quotes a dev-buy launch by eth_call from `from` (the creator: the Launcher delivers to the caller) with minSubjectOut
+ * 1, then sets minSubjectOut to the quoted subjectOut less `slippageBps` (default 1%) and returns the launch to sign.
+ * The member's pool opens inside the launch, so the quote moves only with the launch's own terms and the chain state
+ * it reads. The eth_call needs the creator's funding in place: the native value in its balance and ERC-20 allowances
+ * for every quote and the dev buy (or an ethCall that applies state overrides). `launchFunding` lists exactly what the
+ * Launcher pulls (an ERC-20 dev buy adds its quoteIn to its member's quote) and `buildApprovals` the approve calls to
+ * send, in order, before quoting. A launch the Launcher would refuse,
+ * DevBuyAboveCap included, surfaces as the ethCall's revert (`devBuyRevert` names it).
+ */
+export declare function quoteDevBuy(ethCall: EthCall, q: {
+    manifest: DeploymentManifest;
+    from: Address;
+    token: LaunchToken;
+    root: Address;
+    members: readonly Record<string, unknown>[];
+    advisoryConfigs: readonly Hash[];
+    buy: Omit<DevBuy, "minSubjectOut">;
+    nativeBudget: bigint;
+    deadline: bigint;
+    launchFee: bigint;
+    slippageBps?: number;
+} & DevBuyOptions): Promise<DevBuyQuote>;
+/** Names a Launcher dev-buy revert in `data` (InvalidDevBuy, DevBuyAboveCap, DevBuySlippage, DevBuyPartialFill), or null. */
+export declare function devBuyRevert(data: Hex): string | null;
+/** HookrLauncher.OpeningCheck (r31): every member after the first names a reference pool; zero checks nothing. */
+export interface OpeningCheck {
+    toleranceBps: number;
+    references: readonly PoolKey[];
+}
+/**
+ * HookrLauncher.LaunchParams (r31): launchFamily's input, a launch's Token, root, Members and advisory configs with each
+ * member's knobs (`MemberKnobs`), up to one dev buy per member, a retained-supply cap, an opening check and a new
+ * token's tagline and logo URI.
+ */
+export interface LaunchFamilyParams {
+    token: LaunchToken;
+    root: Address;
+    members: readonly Record<string, unknown>[];
+    knobs: readonly MemberKnobs[];
+    advisoryConfigs: readonly Hash[];
+    buys: readonly DevBuy[];
+    maxRetainedBps: number;
+    opening: OpeningCheck;
+    deadline: bigint;
+    tagline: string;
+    logoURI: string;
+}
+/** A member's knobs at their defaults: no weight, the default divisor, no lock end, the default tempo, linear Snipe. */
+export declare const NO_MEMBER_KNOBS: MemberKnobs;
+/** launchFamily's bounds (HookrLaunchChecks.familyBounds and HookrToken's presentation bounds). */
+export declare const LAUNCH_FAMILY_BOUNDS: {
+    readonly minDivisor: number;
+    readonly maxDivisor: number;
+    readonly maxToleranceBps: number;
+    readonly maxLockEndBlocks: bigint;
+    readonly maxTaglineBytes: number;
+    readonly maxLogoUriBytes: number;
+};
+/** Facts a launchFamily launch is checked against beyond its arguments. */
+export interface LaunchFamilyOptions extends DevBuyOptions {
+    /**
+     * Each reference pool's sqrtPriceX96 on the PoolManager at the launch block, in reference order: with them the opening
+     * check runs offline exactly as HookrLaunchChecks runs it. Without them the launch checks it on chain.
+     */
+    referencePrices?: readonly bigint[];
+}
+/**
+ * The RulesKnobs HookrLauncher._rulesData passes for a launchFamily member (its Rules check them at bind): the five
+ * knob words of its MemberKnobs as given, and on a dynamic fee member its minimum liquidity and, when all four tempo
+ * knobs are zero, the default tempo.
+ */
+export declare function familyRulesKnobs(member: Record<string, unknown>, knobs: MemberKnobs): RulesKnobs;
+/**
+ * HookrLaunchChecks._checkOpening offline: member i's opening sqrt price converted into member 0's quote through its
+ * reference pool's sqrt price, compared on the squares with member 0's within `toleranceBps`. Refuses with the member
+ * and the band, as OpeningOutsideTolerance would.
+ */
+export declare function checkOpeningPrices(subject: Address, members: readonly Record<string, unknown>[], references: readonly PoolKey[], referencePrices: readonly bigint[], toleranceBps: number): void;
+/**
+ * Refuses a launchFamily launch the Launcher would refuse before any pool opens (r31): every launch's checks
+ * (`checkLaunch`, advisory configs), then HookrLaunchChecks.checkFamily's: one MemberKnobs per member, a retained cap
+ * of 0 to 10,000 (an existing token takes only 10,000), a tagline (at most 160 bytes) and logo URI (at most 300) only on
+ * a new token, supply weights on every member or none (new token only, each member's subject budget exactly floor(supply
+ * x weight / 10,000), at most 10,000 in all; `opts.subject` names the new token so the subject side is known), a
+ * divisor of zero or 2 to 10,000 on a dynamic fee member, a lock end of zero or from the last guard end to the launch
+ * block + 100,000, and an opening check of no references at a zero tolerance or one reference per later member, holding
+ * that member's quote and member 0's, at 1 to 1,000 bps (with `opts.referencePrices` the check itself). Each member's
+ * Rules knobs pass the Rules' bind checks (`checkRulesKnobs`), each dev buy `checkDevBuy`, at most one per member, and
+ * with `opts.subject` the unplaced supply alone stays within the dev buy cap (with any buy) and the retained cap.
+ */
+export declare function checkLaunchFamily(m: DeploymentManifest, p: LaunchFamilyParams, nativeBudget: bigint, opts?: LaunchFamilyOptions): void;
+/**
+ * HookrLauncher.launchFamily (r31). `nativeBudget` is the native members' liquidity maxima; the call's value adds every
+ * native member's dev buy and the launch fee (`launchFee`, read at the launch block). Each ERC-20 member pulls its
+ * budget plus its dev buy (`launchFunding`). The Launcher delivers every dev-bought subject to the caller and reverts
+ * DevBuyAboveCap or RetainedAboveCap when the caller would hold more than the dev buy bound or the retained cap. Use
+ * `quoteLaunchFamily` to set each buy's `minSubjectOut`.
+ */
+export declare function buildLaunchFamily(m: DeploymentManifest, p: LaunchFamilyParams, nativeBudget: bigint, launchFee: bigint, opts?: LaunchFamilyOptions): Call;
+/** A quoted launchFamily launch: each dev buy's quoted subject, its minimum and the call to sign. */
+export interface LaunchFamilyQuote {
+    subjectOuts: bigint[];
+    minSubjectOuts: bigint[];
+    call: Call;
+}
+/**
+ * Quotes a launchFamily launch by eth_call from `from` (the creator: the Launcher delivers to the caller) and sets each
+ * dev buy's minSubjectOut to its quoted subject less `slippageBps` (default 1%). Each dev buy runs on its own member's
+ * pool right after that member's add, so no buy moves another's price: the launch is probed with the first k buys for
+ * k = 1..n at minSubjectOut 1, and buy k's subject is the difference of the returned totals. The eth_call needs the
+ * creator's funding in place (`launchFunding`), as for `quoteDevBuy`.
+ */
+export declare function quoteLaunchFamily(ethCall: EthCall, q: {
+    manifest: DeploymentManifest;
+    from: Address;
+    params: LaunchFamilyParams;
+    nativeBudget: bigint;
+    launchFee: bigint;
+    slippageBps?: number;
+} & LaunchFamilyOptions): Promise<LaunchFamilyQuote>;
+/** Names a launchFamily revert in `data` (its own checks and the dev buy's), or null. */
+export declare function launchFamilyRevert(data: Hex): string | null;

package/dist/core/launch.js

@@ -0,0 +1,427 @@
+import { BaseError, decodeErrorResult, decodeFunctionResult } from "viem";
+import { launcherAbi } from "./abi.js";
+import { RELEASE_CONSTANTS } from "./generated.js";
+import { MAX_DEV_BUY_BPS, checkRuleParams, devBuyMemberRefusal, } from "./params.js";
+import { DYNAMIC_FEE_PARAMETERS, checkRulesKnobs, dynamicFeeMinLiquidity, } from "./rules.js";
+import { address, assert, uint, ZERO } from "./schema.js";
+import { buildCall, checkAdvisoryConfigs, checkLaunch, checkLaunchFee } from "./wallet.js";
+/** Slippage `quoteDevBuy` takes off the quoted subjectOut by default: 1%. */
+export const DEFAULT_DEV_BUY_SLIPPAGE_BPS = 100;
+/** The minSubjectOut for a quoted subjectOut: `slippageBps` (0 to 9,999) off it, and never below 1. */
+export function devBuyMinSubjectOut(subjectOut, slippageBps = DEFAULT_DEV_BUY_SLIPPAGE_BPS) {
+    assert(Number.isSafeInteger(slippageBps) && slippageBps >= 0 && slippageBps < 10_000, "Slippage must be 0 to 9,999 bps");
+    assert(uint(subjectOut) > 0n, "The dev buy quoted no subject");
+    const out = (subjectOut * BigInt(10_000 - slippageBps)) / 10000n;
+    return out > 0n ? out : 1n;
+}
+function small(value, bits, label) {
+    const v = typeof value === "number" ? value : typeof value === "bigint" ? Number(value) : NaN;
+    assert(Number.isSafeInteger(v) && v >= 0 && v < 2 ** bits, `Invalid ${label}`);
+    return v;
+}
+function devBuyTerms(member) {
+    const r = member.rules;
+    assert(r !== undefined && r !== null && typeof r === "object", "Launch member without rules");
+    return {
+        guardEndBlock: small(r.guardEndBlock, 40, "guardEndBlock"),
+        snipeTaxPips: small(r.snipeTaxPips, 24, "snipeTaxPips"),
+        maxBuyQuoteAmount: uint(r.maxBuyQuoteAmount, 128),
+    };
+}
+/** The most subject the creator may hold when a dev-buy launch returns: floor(supply * 500 / 10,000), as the Launcher. */
+export function devBuyHoldCap(supply) {
+    return uint(supply) / (10000n / BigInt(MAX_DEV_BUY_BPS));
+}
+/**
+ * The least unplaced supply the Launcher refunds the creator: the supply less every member's subject maximum. The
+ * Launcher refunds supply less the subject the bands actually took, so the refund is at least this.
+ */
+export function unplacedSubjectFloor(token, members, subject) {
+    const s = BigInt(address(subject));
+    let placed = 0n;
+    for (const m of members) {
+        // The pool sorts its currencies; the native quote (zero) always sorts first.
+        const subjectFirst = s < BigInt(address(m.quote, true));
+        placed += uint(subjectFirst ? m.amount0Max : m.amount1Max, 128);
+    }
+    return placed >= token.supply ? 0n : token.supply - placed;
+}
+/** The dev-buy knob context of a launch: every member's Anti-Snipe terms and whether its token is new. */
+export function devBuyContext(token, members, blockNumber) {
+    return {
+        launchMembers: members.map(devBuyTerms),
+        newToken: address(token.existing, true) === ZERO,
+        ...(blockNumber === undefined ? {} : { blockNumber }),
+    };
+}
+/**
+ * Refuses a dev buy HookrLauncher._checkBuy refuses before it swaps (InvalidDevBuy): an existing token, a zero quoteIn
+ * or minSubjectOut, an unknown member, a quoteIn above int128, a lock above MAX_DEV_BUY_LOCK_BLOCKS, or a guarded
+ * member whose guard ends by `blockNumber`, without a Snipe or with a per-block cap below quoteIn (an unguarded member
+ * takes any dev buy, r31). Then checks the knobs against `RULE_PARAMS.devBuy`.
+ */
+export function checkDevBuy(buy, token, members, blockNumber) {
+    assert(address(token.existing, true) === ZERO, "A dev buy needs a new token");
+    assert(Number.isSafeInteger(buy.member) && buy.member >= 0 && buy.member < members.length, "The dev buy names no family member");
+    assert(uint(buy.quoteIn, 128) > 0n, "A dev buy spends a positive quoteIn; launch without one instead");
+    const refusal = devBuyMemberRefusal(devBuyTerms(members[buy.member]), buy.quoteIn, blockNumber);
+    assert(refusal === null, refusal ?? "");
+    checkRuleParams("devBuy", buy, devBuyContext(token, members, blockNumber));
+}
+/**
+ * launchAdvised with a dev buy (HookrLauncher.launchWithBuy). `nativeBudget` is the native members' liquidity maxima,
+ * as for buildLaunch; the call's value adds `buy.quoteIn` when the dev-buy member's quote is native, and the launch fee
+ * (`launchFee`, read at the launch block). An ERC-20 quote is pulled from the caller with that member's budget, so
+ * approve the Launcher for both. The Launcher delivers the dev-bought subject to the caller and reverts DevBuyAboveCap
+ * when the caller would hold more than 5% of the supply, dev-bought and unplaced together. Use `quoteDevBuy` to set
+ * `minSubjectOut`.
+ */
+export function buildLaunchWithBuy(m, token, root, members, advisoryConfigs, buy, nativeBudget, deadline, launchFee, opts = {}) {
+    checkLaunch(m, token, root, members, nativeBudget, deadline);
+    checkAdvisoryConfigs(members, advisoryConfigs);
+    checkDevBuy(buy, token, members, opts.blockNumber);
+    if (opts.subject !== undefined) {
+        const floor = unplacedSubjectFloor(token, members, opts.subject);
+        const cap = devBuyHoldCap(token.supply);
+        assert(floor <= cap, `The unplaced supply alone (${floor}) is above the ${cap} a dev-buy creator may hold; place more of the supply`);
+    }
+    const native = address(members[buy.member].quote, true) === ZERO;
+    return buildCall(m, "launcher", launcherAbi, "launchWithBuy", [
+        token,
+        root,
+        members,
+        advisoryConfigs,
+        { member: buy.member, quoteIn: buy.quoteIn, minSubjectOut: buy.minSubjectOut, lockBlocks: buy.lockBlocks },
+        deadline,
+    ], nativeBudget + (native ? buy.quoteIn : 0n) + checkLaunchFee(launchFee));
+}
+/**
+ * Quotes a dev-buy launch by eth_call from `from` (the creator: the Launcher delivers to the caller) with minSubjectOut
+ * 1, then sets minSubjectOut to the quoted subjectOut less `slippageBps` (default 1%) and returns the launch to sign.
+ * The member's pool opens inside the launch, so the quote moves only with the launch's own terms and the chain state
+ * it reads. The eth_call needs the creator's funding in place: the native value in its balance and ERC-20 allowances
+ * for every quote and the dev buy (or an ethCall that applies state overrides). `launchFunding` lists exactly what the
+ * Launcher pulls (an ERC-20 dev buy adds its quoteIn to its member's quote) and `buildApprovals` the approve calls to
+ * send, in order, before quoting. A launch the Launcher would refuse,
+ * DevBuyAboveCap included, surfaces as the ethCall's revert (`devBuyRevert` names it).
+ */
+export async function quoteDevBuy(ethCall, q) {
+    const slippage = q.slippageBps ?? DEFAULT_DEV_BUY_SLIPPAGE_BPS;
+    devBuyMinSubjectOut(1n, slippage);
+    const opts = { blockNumber: q.blockNumber, subject: q.subject };
+    const build = (minSubjectOut) => buildLaunchWithBuy(q.manifest, q.token, q.root, q.members, q.advisoryConfigs, { ...q.buy, minSubjectOut }, q.nativeBudget, q.deadline, q.launchFee, opts);
+    const probe = build(1n);
+    const data = await ethCall({ from: address(q.from), to: probe.to, data: probe.data, value: probe.value });
+    const [, subject, subjectOut] = decodeFunctionResult({ abi: launcherAbi, functionName: "launchWithBuy", data });
+    if (q.subject !== undefined)
+        assert(address(subject) === address(q.subject), "The quoted launch created a different token");
+    const minSubjectOut = devBuyMinSubjectOut(subjectOut, slippage);
+    return { subjectOut, minSubjectOut, call: build(minSubjectOut) };
+}
+/** Names a Launcher dev-buy revert in `data` (InvalidDevBuy, DevBuyAboveCap, DevBuySlippage, DevBuyPartialFill), or null. */
+export function devBuyRevert(data) {
+    try {
+        const e = decodeErrorResult({ abi: launcherAbi, data });
+        switch (e.errorName) {
+            case "InvalidDevBuy":
+                return "The Launcher refuses the dev buy's terms (member, amount, lock or guard)";
+            case "DevBuyAboveCap":
+                return `The creator would hold ${e.args[0]} of the subject, above the ${e.args[1]} (5% of supply) cap`;
+            case "DevBuySlippage":
+                return `The dev buy delivers ${e.args[0]}, below minSubjectOut ${e.args[1]}`;
+            case "DevBuyPartialFill":
+                return `The member's band filled ${e.args[0]} of the dev buy's ${e.args[1]}; widen the band or buy less`;
+        }
+    }
+    catch (error) {
+        if (!(error instanceof BaseError))
+            throw error;
+    }
+    return null;
+}
+/** A member's knobs at their defaults: no weight, the default divisor, no lock end, the default tempo, linear Snipe. */
+export const NO_MEMBER_KNOBS = Object.freeze({
+    subjectWeightBps: 0,
+    dynamicFeeLiquidityDivisor: 0,
+    lockEndBlock: 0n,
+    windowSeconds: 0,
+    resetSeconds: 0,
+    carryBps: 0,
+    moveTicks: 0,
+    snipeCurve: 0,
+});
+/** launchFamily's bounds (HookrLaunchChecks.familyBounds and HookrToken's presentation bounds). */
+export const LAUNCH_FAMILY_BOUNDS = {
+    minDivisor: Number(RELEASE_CONSTANTS.LAUNCH_MIN_DYNAMIC_FEE_LIQUIDITY_DIVISOR),
+    maxDivisor: Number(RELEASE_CONSTANTS.LAUNCH_MAX_DYNAMIC_FEE_LIQUIDITY_DIVISOR),
+    maxToleranceBps: Number(RELEASE_CONSTANTS.LAUNCH_MAX_OPENING_TOLERANCE_BPS),
+    maxLockEndBlocks: BigInt(RELEASE_CONSTANTS.LAUNCH_MAX_LOCK_END_BLOCKS),
+    maxTaglineBytes: Number(RELEASE_CONSTANTS.TOKEN_MAX_TAGLINE_BYTES),
+    maxLogoUriBytes: Number(RELEASE_CONSTANTS.TOKEN_MAX_LOGO_URI_BYTES),
+};
+const BPS = 10000n;
+const Q96 = 1n << 96n;
+const MIN_SQRT_PRICE = 4295128739n;
+const MAX_SQRT_PRICE = 1461446703485210103287273052203988822378723970342n;
+function utf8Bytes(text) {
+    return new TextEncoder().encode(text).length;
+}
+/**
+ * The RulesKnobs HookrLauncher._rulesData passes for a launchFamily member (its Rules check them at bind): the five
+ * knob words of its MemberKnobs as given, and on a dynamic fee member its minimum liquidity and, when all four tempo
+ * knobs are zero, the default tempo.
+ */
+export function familyRulesKnobs(member, knobs) {
+    const r = member.rules;
+    const k = {
+        minDynamicFeeLiquidity: 0n,
+        windowSeconds: knobs.windowSeconds,
+        resetSeconds: knobs.resetSeconds,
+        carryBps: knobs.carryBps,
+        moveTicks: knobs.moveTicks,
+        snipeCurve: knobs.snipeCurve,
+    };
+    if (Number(r.dynamicFeeSens) !== 0) {
+        k.minDynamicFeeLiquidity = dynamicFeeMinLiquidity(uint(member.liquidity, 128), knobs.dynamicFeeLiquidityDivisor);
+        if (k.windowSeconds === 0 && k.resetSeconds === 0 && k.carryBps === 0 && k.moveTicks === 0) {
+            k.windowSeconds = DYNAMIC_FEE_PARAMETERS.window;
+            k.resetSeconds = DYNAMIC_FEE_PARAMETERS.reset;
+            k.carryBps = DYNAMIC_FEE_PARAMETERS.carryBps;
+            k.moveTicks = DYNAMIC_FEE_PARAMETERS.moveTicks;
+        }
+    }
+    return k;
+}
+/** sqrtPriceX96, or floor(2^192 / sqrtPriceX96) when `invert` (HookrLaunchChecks._oriented). */
+function oriented(sqrtPriceX96, invert) {
+    return invert ? (1n << 192n) / sqrtPriceX96 : sqrtPriceX96;
+}
+/** A member's opening sqrt price, refused outside [MIN_SQRT_PRICE, MAX_SQRT_PRICE) as the PoolManager refuses it. */
+function memberPrice(member) {
+    const p = uint(member.sqrtPriceX96, 160);
+    assert(p >= MIN_SQRT_PRICE && p < MAX_SQRT_PRICE, "A member's opening price is outside the PoolManager's range");
+    return p;
+}
+/**
+ * HookrLaunchChecks._checkOpening offline: member i's opening sqrt price converted into member 0's quote through its
+ * reference pool's sqrt price, compared on the squares with member 0's within `toleranceBps`. Refuses with the member
+ * and the band, as OpeningOutsideTolerance would.
+ */
+export function checkOpeningPrices(subject, members, references, referencePrices, toleranceBps) {
+    assert(referencePrices.length === references.length, "One reference price per reference pool");
+    const s = BigInt(address(subject));
+    const quote0 = address(members[0].quote, true);
+    const s0 = oriented(memberPrice(members[0]), s > BigInt(quote0));
+    const t = BigInt(toleranceBps);
+    const low = s0 * (BPS - t) * s0;
+    const high = s0 * (BPS + t) * s0;
+    for (let i = 1; i < members.length; i++) {
+        const ref = references[i - 1];
+        const quote = address(members[i].quote, true);
+        const c0 = address(ref.currency0, true);
+        const sqrtReference = uint(referencePrices[i - 1], 160);
+        assert(sqrtReference !== 0n, `Member ${i}'s reference pool is not initialized (OpeningReferenceUninitialized)`);
+        const converted = (oriented(memberPrice(members[i]), s > BigInt(quote)) * oriented(sqrtReference, c0 !== quote)) / Q96;
+        const square = converted * 100n * (converted * 100n);
+        assert(square >= low && square <= high, `Member ${i} opens outside ${toleranceBps} bps of member 0's price through its reference (OpeningOutsideTolerance)`);
+    }
+}
+/**
+ * Refuses a launchFamily launch the Launcher would refuse before any pool opens (r31): every launch's checks
+ * (`checkLaunch`, advisory configs), then HookrLaunchChecks.checkFamily's: one MemberKnobs per member, a retained cap
+ * of 0 to 10,000 (an existing token takes only 10,000), a tagline (at most 160 bytes) and logo URI (at most 300) only on
+ * a new token, supply weights on every member or none (new token only, each member's subject budget exactly floor(supply
+ * x weight / 10,000), at most 10,000 in all; `opts.subject` names the new token so the subject side is known), a
+ * divisor of zero or 2 to 10,000 on a dynamic fee member, a lock end of zero or from the last guard end to the launch
+ * block + 100,000, and an opening check of no references at a zero tolerance or one reference per later member, holding
+ * that member's quote and member 0's, at 1 to 1,000 bps (with `opts.referencePrices` the check itself). Each member's
+ * Rules knobs pass the Rules' bind checks (`checkRulesKnobs`), each dev buy `checkDevBuy`, at most one per member, and
+ * with `opts.subject` the unplaced supply alone stays within the dev buy cap (with any buy) and the retained cap.
+ */
+export function checkLaunchFamily(m, p, nativeBudget, opts = {}) {
+    checkLaunch(m, p.token, p.root, p.members, nativeBudget, p.deadline);
+    checkAdvisoryConfigs(p.members, p.advisoryConfigs);
+    const n = p.members.length;
+    const b = LAUNCH_FAMILY_BOUNDS;
+    assert(p.knobs.length === n, "One MemberKnobs per member (InvalidFamily)");
+    const isNew = address(p.token.existing, true) === ZERO;
+    assert(Number.isSafeInteger(p.maxRetainedBps) &&
+        p.maxRetainedBps >= 0 &&
+        p.maxRetainedBps <= 10_000 &&
+        (isNew || p.maxRetainedBps === 10_000), "The retained cap is 0 to 10,000 bps, and 10,000 for an existing token (InvalidRetainedCap)");
+    if (p.tagline !== "" || p.logoURI !== "")
+        assert(isNew, "Only a new token takes a tagline and logo URI (InvalidFunding)");
+    assert(utf8Bytes(p.tagline) <= b.maxTaglineBytes, `The tagline is above ${b.maxTaglineBytes} bytes (InvalidMetadata)`);
+    assert(utf8Bytes(p.logoURI) <= b.maxLogoUriBytes, `The logo URI is above ${b.maxLogoUriBytes} bytes (InvalidMetadata)`);
+    const weighted = p.knobs[0].subjectWeightBps !== 0;
+    assert(!weighted || isNew, "Supply weights need a new token (InvalidWeights)");
+    const lastGuardEnd = p.members.reduce((max, member) => {
+        const end = BigInt(Number(member.rules.guardEndBlock));
+        return end > max ? end : max;
+    }, 0n);
+    let weightSum = 0;
+    p.knobs.forEach((k, i) => {
+        const member = p.members[i];
+        const rules = member.rules;
+        assert(Number.isSafeInteger(k.subjectWeightBps) && k.subjectWeightBps >= 0 && k.subjectWeightBps < 2 ** 16, `Invalid member ${i} weight`);
+        assert((k.subjectWeightBps !== 0) === weighted, "Supply weights on every member or none (InvalidWeights)");
+        if (weighted) {
+            assert(opts.subject !== undefined, "Pass the new token's address (buildPredictToken) to check supply weights");
+            weightSum += k.subjectWeightBps;
+            const subjectFirst = BigInt(address(opts.subject)) < BigInt(address(member.quote, true));
+            const budget = uint(subjectFirst ? member.amount0Max : member.amount1Max, 128);
+            const expected = (uint(p.token.supply) * BigInt(k.subjectWeightBps)) / BPS;
+            assert(budget === expected, `Member ${i}'s subject budget ${budget} is not its weight's ${expected} (WeightMismatch)`);
+        }
+        const divisor = k.dynamicFeeLiquidityDivisor;
+        assert(Number.isSafeInteger(divisor) && divisor >= 0 && divisor < 2 ** 16, `Invalid member ${i} divisor`);
+        assert(divisor === 0 || (Number(rules.dynamicFeeSens) !== 0 && divisor >= b.minDivisor && divisor <= b.maxDivisor), `Member ${i}'s divisor is zero, or ${b.minDivisor} to ${b.maxDivisor} on a dynamic fee member (InvalidDivisor)`);
+        const end = uint(k.lockEndBlock, 64);
+        if (end !== 0n)
+            assert(end >= lastGuardEnd && (opts.blockNumber === undefined || end <= opts.blockNumber + b.maxLockEndBlocks), `Member ${i}'s lock end is before the last guard end or past the launch block + 100,000 (InvalidLockEnd)`);
+        // The form the Launcher binds: recapture members the 30-word data, members with a knob the 22-word data.
+        const rulesKnobs = familyRulesKnobs(member, k);
+        const knobbed = rulesKnobs.minDynamicFeeLiquidity !== 0n ||
+            rulesKnobs.windowSeconds !== 0 ||
+            rulesKnobs.resetSeconds !== 0 ||
+            rulesKnobs.carryBps !== 0 ||
+            rulesKnobs.moveTicks !== 0 ||
+            rulesKnobs.snipeCurve !== 0;
+        checkRulesKnobs({ dynamicFeeSens: Number(rules.dynamicFeeSens), snipeDecaySeconds: Number(rules.snipeDecaySeconds) }, rulesKnobs, member.recapture.on ? "recapture" : knobbed ? "knobs" : "config");
+    });
+    assert(weightSum <= 10_000, "Supply weights sum above 10,000 bps (InvalidWeights)");
+    const { toleranceBps, references } = p.opening;
+    if (toleranceBps !== 0 || references.length !== 0) {
+        assert(Number.isSafeInteger(toleranceBps) && toleranceBps >= 1 && toleranceBps <= b.maxToleranceBps, `The opening tolerance is 1 to ${b.maxToleranceBps} bps (OpeningToleranceOutOfRange)`);
+        assert(references.length === n - 1, "One reference pool per member after the first (InvalidFamily)");
+        const quote0 = address(p.members[0].quote, true);
+        references.forEach((ref, j) => {
+            const quote = address(p.members[j + 1].quote, true);
+            const c0 = address(ref.currency0, true);
+            const c1 = address(ref.currency1, true);
+            assert((c0 === quote && c1 === quote0) || (c0 === quote0 && c1 === quote), `Member ${j + 1}'s reference pool must hold its quote and member 0's (OpeningReferenceMismatch)`);
+        });
+        if (opts.referencePrices !== undefined) {
+            assert(opts.subject !== undefined, "Pass the subject's address to run the opening check offline");
+            checkOpeningPrices(opts.subject, p.members, references, opts.referencePrices, toleranceBps);
+        }
+    }
+    const seen = new Set();
+    for (const buy of p.buys) {
+        checkDevBuy(buy, p.token, p.members, opts.blockNumber);
+        assert(!seen.has(buy.member), "At most one dev buy per member (InvalidDevBuy)");
+        seen.add(buy.member);
+    }
+    if (opts.subject !== undefined && isNew) {
+        const floor = unplacedSubjectFloor(p.token, p.members, opts.subject);
+        if (p.buys.length !== 0) {
+            const cap = devBuyHoldCap(p.token.supply);
+            assert(floor <= cap, `The unplaced supply alone (${floor}) is above the ${cap} a dev-buy creator may hold`);
+        }
+        const retained = (uint(p.token.supply) * BigInt(p.maxRetainedBps)) / BPS;
+        assert(floor <= retained, `The unplaced supply alone (${floor}) is above the retained cap ${retained} (RetainedAboveCap)`);
+    }
+}
+/**
+ * HookrLauncher.launchFamily (r31). `nativeBudget` is the native members' liquidity maxima; the call's value adds every
+ * native member's dev buy and the launch fee (`launchFee`, read at the launch block). Each ERC-20 member pulls its
+ * budget plus its dev buy (`launchFunding`). The Launcher delivers every dev-bought subject to the caller and reverts
+ * DevBuyAboveCap or RetainedAboveCap when the caller would hold more than the dev buy bound or the retained cap. Use
+ * `quoteLaunchFamily` to set each buy's `minSubjectOut`.
+ */
+export function buildLaunchFamily(m, p, nativeBudget, launchFee, opts = {}) {
+    checkLaunchFamily(m, p, nativeBudget, opts);
+    const nativeBuys = p.buys.reduce((sum, buy) => (address(p.members[buy.member].quote, true) === ZERO ? sum + buy.quoteIn : sum), 0n);
+    return buildCall(m, "launcher", launcherAbi, "launchFamily", [
+        {
+            token: p.token,
+            root: p.root,
+            members: p.members,
+            knobs: p.knobs,
+            advisoryConfigs: p.advisoryConfigs,
+            buys: p.buys.map((buy) => ({
+                member: buy.member,
+                quoteIn: buy.quoteIn,
+                minSubjectOut: buy.minSubjectOut,
+                lockBlocks: buy.lockBlocks,
+            })),
+            maxRetainedBps: p.maxRetainedBps,
+            opening: p.opening,
+            deadline: p.deadline,
+            tagline: p.tagline,
+            logoURI: p.logoURI,
+        },
+    ], nativeBudget + nativeBuys + checkLaunchFee(launchFee));
+}
+/**
+ * Quotes a launchFamily launch by eth_call from `from` (the creator: the Launcher delivers to the caller) and sets each
+ * dev buy's minSubjectOut to its quoted subject less `slippageBps` (default 1%). Each dev buy runs on its own member's
+ * pool right after that member's add, so no buy moves another's price: the launch is probed with the first k buys for
+ * k = 1..n at minSubjectOut 1, and buy k's subject is the difference of the returned totals. The eth_call needs the
+ * creator's funding in place (`launchFunding`), as for `quoteDevBuy`.
+ */
+export async function quoteLaunchFamily(ethCall, q) {
+    const slippage = q.slippageBps ?? DEFAULT_DEV_BUY_SLIPPAGE_BPS;
+    devBuyMinSubjectOut(1n, slippage);
+    const opts = {
+        blockNumber: q.blockNumber,
+        subject: q.subject,
+        referencePrices: q.referencePrices,
+    };
+    const build = (buys) => buildLaunchFamily(q.manifest, { ...q.params, buys }, q.nativeBudget, q.launchFee, opts);
+    const subjectOuts = [];
+    let previous = 0n;
+    for (let k = 1; k <= q.params.buys.length; k++) {
+        const probe = build(q.params.buys.slice(0, k).map((buy) => ({ ...buy, minSubjectOut: 1n })));
+        const data = await ethCall({ from: address(q.from), to: probe.to, data: probe.data, value: probe.value });
+        const [, subject, total] = decodeFunctionResult({ abi: launcherAbi, functionName: "launchFamily", data });
+        if (q.subject !== undefined)
+            assert(address(subject) === address(q.subject), "The quoted launch created a different token");
+        subjectOuts.push(total - previous);
+        previous = total;
+    }
+    const minSubjectOuts = subjectOuts.map((out) => devBuyMinSubjectOut(out, slippage));
+    const buys = q.params.buys.map((buy, i) => ({ ...buy, minSubjectOut: minSubjectOuts[i] }));
+    return { subjectOuts, minSubjectOuts, call: build(buys) };
+}
+/** Names a launchFamily revert in `data` (its own checks and the dev buy's), or null. */
+export function launchFamilyRevert(data) {
+    const devBuy = devBuyRevert(data);
+    if (devBuy !== null)
+        return devBuy;
+    try {
+        const e = decodeErrorResult({ abi: launcherAbi, data });
+        const a = e.args;
+        switch (e.errorName) {
+            case "InvalidFamily":
+                return "The family's members, knobs, advisory configs or references do not line up";
+            case "InvalidFunding":
+                return "The launch's value is not the native budgets, the native dev buys and the launch fee, or an existing token took a tagline or logo";
+            case "InvalidRetainedCap":
+                return `The retained cap ${a?.[0]} is above 10,000 bps, or not 10,000 for an existing token`;
+            case "RetainedAboveCap":
+                return `The creator would hold ${a?.[0]} of the subject, above the retained cap ${a?.[1]}`;
+            case "InvalidWeights":
+                return "Supply weights go on every member of a new token or on none, at most 10,000 bps in all";
+            case "WeightMismatch":
+                return `Member ${a?.[0]}'s subject budget ${a?.[1]} is not its weight's ${a?.[2]}`;
+            case "InvalidDivisor":
+                return `Member ${a?.[0]}'s dynamic fee liquidity divisor ${a?.[1]} is out of bounds`;
+            case "InvalidLockEnd":
+                return `Member ${a?.[0]}'s lock end ${a?.[1]} is before the last guard end or more than 100,000 blocks out`;
+            case "OpeningToleranceOutOfRange":
+                return `The opening check's tolerance ${a?.[0]} bps is outside 1 to 1,000`;
+            case "OpeningReferenceMismatch":
+                return `Member ${a?.[0]}'s reference pool does not hold its quote and member 0's quote`;
+            case "OpeningReferenceUninitialized":
+                return `Member ${a?.[0]}'s reference pool has no price`;
+            case "OpeningOutsideTolerance":
+                return `Member ${a?.[0]} would open outside the tolerance of member 0's price`;
+        }
+    }
+    catch (error) {
+        if (!(error instanceof BaseError))
+            throw error;
+    }
+    return null;
+}