hookr-sdk 0.1.0

package/dist/chain.d.ts

@@ -0,0 +1,45 @@
+import type { Address, Hex } from "viem";
+/**
+ * Robinhood Chain, and Hookr's one live root hook on it.
+ *
+ * Every value here is a literal copy of `src/lib/v2-deployments.ts` (the addresses, read from
+ * the app's own deployment evidence) and `src/lib/chain.ts` (the RPC and explorer origin) in the
+ * Hookr app. `src/test/hookr-sdk-parity.test.ts` in that app asserts this file agrees with both,
+ * so a redeploy or an RPC change that is not mirrored here fails that suite.
+ *
+ * There is exactly one root today: `HookrModularHookV6`, deployed as `ADDRESSES.root`. Every V2
+ * pool's `PoolKey.hooks` is that address.
+ */
+/** Robinhood Chain's id. */
+export declare const CHAIN_ID = 4663;
+/** The chain's public, keyless RPC endpoint. */
+export declare const RPC_URL = "https://rpc.mainnet.chain.robinhood.com";
+/** Origin of the chain's block explorer (Blockscout). No trailing slash. */
+export declare const EXPLORER_URL = "https://robinhoodchain.blockscout.com";
+/** The V2 contracts and ids a third-party integration calls or reads. */
+export declare const ADDRESSES: Readonly<{
+    /** `HookrModularHookV6` — `hooks` in every V2 `PoolKey`. The one live root. */
+    root: Address;
+    /** `HookrMarketCoordinatorV5` — opens markets, collects founding fees, resolves the share tier. */
+    coordinator: Address;
+    /** `HookrKernelRouterV3` — the swap router that pays into and out of the pot. */
+    router: Address;
+    /** `HookrKernelQuoterV1` — the quoter that runs the full module loop. */
+    quoter: Address;
+    /** `HookrNativeMechanicsBlockV2` — the one native block every V2 stack carries; also where claims are paid. */
+    nativeBlock: Address;
+    /** `HookrStackRegistryV2` — read-only, a pool's frozen config and module list. */
+    registry: Address;
+    /** `HookrModuleCatalogV1` — the on-chain catalog of admitted modules. */
+    catalog: Address;
+    /** `HookrReleaseCreate2FactoryV1` — the CREATE2 factory the release was deployed through. */
+    factory: Address;
+}>;
+/** The native-mechanics module id every V2 pool's one module is keyed by in the registry. */
+export declare const MODULE_ID: Hex;
+/** The coordinator's kernel id for the root hook, carried in `MarketParams.kernelId`. */
+export declare const KERNEL_ID: Hex;
+/** Native ETH as a v4 currency: the zero address. Always `currency0` when it is one side of a pool. */
+export declare const NATIVE_ADDRESS: Address;
+export declare function explorerAddressUrl(address: Address): string;
+export declare function explorerTxUrl(hash: Hex): string;

package/dist/chain.js

@@ -0,0 +1,48 @@
+/**
+ * Robinhood Chain, and Hookr's one live root hook on it.
+ *
+ * Every value here is a literal copy of `src/lib/v2-deployments.ts` (the addresses, read from
+ * the app's own deployment evidence) and `src/lib/chain.ts` (the RPC and explorer origin) in the
+ * Hookr app. `src/test/hookr-sdk-parity.test.ts` in that app asserts this file agrees with both,
+ * so a redeploy or an RPC change that is not mirrored here fails that suite.
+ *
+ * There is exactly one root today: `HookrModularHookV6`, deployed as `ADDRESSES.root`. Every V2
+ * pool's `PoolKey.hooks` is that address.
+ */
+/** Robinhood Chain's id. */
+export const CHAIN_ID = 4663;
+/** The chain's public, keyless RPC endpoint. */
+export const RPC_URL = "https://rpc.mainnet.chain.robinhood.com";
+/** Origin of the chain's block explorer (Blockscout). No trailing slash. */
+export const EXPLORER_URL = "https://robinhoodchain.blockscout.com";
+/** The V2 contracts and ids a third-party integration calls or reads. */
+export const ADDRESSES = Object.freeze({
+    /** `HookrModularHookV6` — `hooks` in every V2 `PoolKey`. The one live root. */
+    root: "0xb3cA29cF721380CEe8b8e4755F3865Ebc68Fe8cC",
+    /** `HookrMarketCoordinatorV5` — opens markets, collects founding fees, resolves the share tier. */
+    coordinator: "0x53A192A3fCeE94Da77916B461E0cCa2Dd6402442",
+    /** `HookrKernelRouterV3` — the swap router that pays into and out of the pot. */
+    router: "0xf0E528c39f33F565876cbaa7e0DFaCa38Df966E9",
+    /** `HookrKernelQuoterV1` — the quoter that runs the full module loop. */
+    quoter: "0x5Ba8FBbB4aB20Ff6Daf0ecDEBe3784f869BcB1B5",
+    /** `HookrNativeMechanicsBlockV2` — the one native block every V2 stack carries; also where claims are paid. */
+    nativeBlock: "0xD700492b504ba5A72D7de28dDe11Cd7985a7F1ae",
+    /** `HookrStackRegistryV2` — read-only, a pool's frozen config and module list. */
+    registry: "0x5b7f1A117A83aaac15B0698Aa4eB9D53fE5f5BA3",
+    /** `HookrModuleCatalogV1` — the on-chain catalog of admitted modules. */
+    catalog: "0x6a3561d5B6305E2229F30EDF66702e8Bc4fA19D1",
+    /** `HookrReleaseCreate2FactoryV1` — the CREATE2 factory the release was deployed through. */
+    factory: "0xBc54e888C1A5B71744B035DfeC5611B4DC69ccDe",
+});
+/** The native-mechanics module id every V2 pool's one module is keyed by in the registry. */
+export const MODULE_ID = "0x961091565aaf4eaa4996296fda9772957e61d18d90b965111a59ded2bbb5e774";
+/** The coordinator's kernel id for the root hook, carried in `MarketParams.kernelId`. */
+export const KERNEL_ID = "0x1be0c118b1c6520d97de31ee9f0c33069f0e715ffcdcb16c87a343752bb5be14";
+/** Native ETH as a v4 currency: the zero address. Always `currency0` when it is one side of a pool. */
+export const NATIVE_ADDRESS = "0x0000000000000000000000000000000000000000";
+export function explorerAddressUrl(address) {
+    return `${EXPLORER_URL}/address/${address}`;
+}
+export function explorerTxUrl(hash) {
+    return `${EXPLORER_URL}/tx/${hash}`;
+}

package/dist/claims.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Claim what the native block owes: pot winnings and royalties, pooled per quote currency
+ * across every pool. Copied from the app's `src/lib/agent-skill.ts` ("Claim"):
+ *
+ *   nativeMechanicsBlock.claimable(quote, account) view returns (uint256)
+ *   nativeMechanicsBlock.claim(quote)        // pays msg.sender
+ *   nativeMechanicsBlock.claimTo(quote, to)  // pays to
+ *
+ * `claim`/`claimTo` pay pot winnings and royalties; read `claimable` first, since a zero balance
+ * reverts. `quote` is the zero address for a claim in native ETH.
+ */
+import type { Address } from "viem";
+import { hookrNativeMechanicsBlockV2Abi } from "./abi.js";
+export type ReadCall<F extends string> = Readonly<{
+    address: Address;
+    abi: typeof hookrNativeMechanicsBlockV2Abi;
+    functionName: F;
+    args: readonly unknown[];
+}>;
+export type WriteCall<F extends string> = Readonly<{
+    address: Address;
+    abi: typeof hookrNativeMechanicsBlockV2Abi;
+    functionName: F;
+    args: readonly unknown[];
+    value: bigint;
+}>;
+/** `nativeMechanicsBlock.claimable(quote, account)`. Read with viem's `readContract`. */
+export declare function claimableCall(quote: Address, account: Address): ReadCall<"claimable">;
+/** `nativeMechanicsBlock.claim(quote)`: pays `msg.sender`. Reverts on a zero balance. */
+export declare function claimCall(quote: Address): WriteCall<"claim">;
+/** `nativeMechanicsBlock.claimTo(quote, to)`: pays `to`. Reverts on a zero balance. */
+export declare function claimToCall(quote: Address, to: Address): WriteCall<"claimTo">;

package/dist/claims.js

@@ -0,0 +1,31 @@
+import { hookrNativeMechanicsBlockV2Abi } from "./abi.js";
+import { ADDRESSES } from "./chain.js";
+/** `nativeMechanicsBlock.claimable(quote, account)`. Read with viem's `readContract`. */
+export function claimableCall(quote, account) {
+    return Object.freeze({
+        address: ADDRESSES.nativeBlock,
+        abi: hookrNativeMechanicsBlockV2Abi,
+        functionName: "claimable",
+        args: [quote, account],
+    });
+}
+/** `nativeMechanicsBlock.claim(quote)`: pays `msg.sender`. Reverts on a zero balance. */
+export function claimCall(quote) {
+    return Object.freeze({
+        address: ADDRESSES.nativeBlock,
+        abi: hookrNativeMechanicsBlockV2Abi,
+        functionName: "claim",
+        args: [quote],
+        value: 0n,
+    });
+}
+/** `nativeMechanicsBlock.claimTo(quote, to)`: pays `to`. Reverts on a zero balance. */
+export function claimToCall(quote, to) {
+    return Object.freeze({
+        address: ADDRESSES.nativeBlock,
+        abi: hookrNativeMechanicsBlockV2Abi,
+        functionName: "claimTo",
+        args: [quote, to],
+        value: 0n,
+    });
+}

package/dist/fees.d.ts

@@ -0,0 +1,59 @@
+/**
+ * The V2 fee model: base fee bounds, and the per-stream recipient/protocol split.
+ *
+ * Bounds are copied from the app's `src/lib/v2-fee-tiers.ts` and `src/lib/v2-combinations.ts`.
+ * `feeModel` walks a stack exactly the way `src/lib/v2-fee-streams.ts`'s `buildV2FeeStreams`
+ * does — same streams, same order, same split arithmetic — restated in wei terms at a supplied
+ * sample amount (default one whole unit, 1e18) rather than the app's formatted, labelled rows.
+ * `src/test/hookr-sdk-parity.test.ts` calls both on the same three configurations and the same
+ * sample amount and asserts the wei splits agree.
+ */
+import { type RuleBlock } from "./rules.js";
+/** `HookrNativeMechanicsBlockV2.MAX_TOTAL_FEE_PIPS`: 50% of a swap, base + surge + snipe. */
+export declare const MAX_TOTAL_FEE_PIPS = 500000;
+/** Smallest base fee accepted. One pip is a millionth; 100 pips is 0.01%. */
+export declare const MIN_BASE_FEE_PIPS = 100;
+/** The base fee's admissible range, in pips. */
+export declare const baseFeeBounds: Readonly<{
+    min: number;
+    max: number;
+}>;
+/** `HookrMarketCoordinatorV5.defaultProtocolShareBps`: the protocol's default share of each add-on. */
+export declare const DEFAULT_PROTOCOL_SHARE_BPS = 2000;
+/** `HookrNativeMechanicsBlockV2.MAX_PROTOCOL_SHARE_BPS`: the hard ceiling on that share. */
+export declare const MAX_PROTOCOL_SHARE_BPS = 5000;
+export type FeeStreamKind = "baseFee" | "surge" | "snipeTax" | "lpReward" | "pot" | "burn";
+export type FeeStreamSplit = Readonly<{
+    stream: FeeStreamKind;
+    /** The rule that controls this stream; null for the base fee, which is not a placeable rule. */
+    rule: "snipe" | "fee" | "burn" | "lp" | "pot" | null;
+    /** This stream's total, in wei of the sample amount. For `burn`, the protocol's quote-side
+     *  slice only: the burned share itself is a rate on the token OUTPUT (`burnNetBps`), which is
+     *  not known until the pool prices the swap. */
+    totalWei: bigint;
+    recipientWei: bigint;
+    protocolWei: bigint;
+    /** Set only on the `burn` row: the share of token output burned, net of the protocol's slice. */
+    burnNetBps: number | null;
+}>;
+export type FeeModelResult = Readonly<{
+    amountWei: bigint;
+    protocolShareBps: number;
+    streams: readonly FeeStreamSplit[];
+    /** Every stream's protocol slice, summed. */
+    totalProtocolWei: bigint;
+}>;
+/**
+ * Walk a stack of rule blocks through the fee model for one sample amount, exactly as
+ * `buildV2FeeStreams` does: the base fee is always shown; surge, the snipe tax, the LP-reward
+ * and pot cuts, and the burn cut each appear only while their rule is on the stack with a
+ * nonzero rate. The snipe-tax row is shown as if the guard were open, because that is the only
+ * state in which it is ever nonzero — the app's row says so too.
+ *
+ * `baseFeePips` is the stack's Base LP fee (see `compileRuleBlocks`); `amountWei` defaults to
+ * one whole unit (1e18) of the pool's quote currency.
+ */
+export declare function feeModel(baseFeePips: number, blocks: readonly RuleBlock[], opts?: Readonly<{
+    amountWei?: bigint;
+    protocolShareBps?: number;
+}>): FeeModelResult;

package/dist/fees.js

@@ -0,0 +1,142 @@
+/**
+ * The V2 fee model: base fee bounds, and the per-stream recipient/protocol split.
+ *
+ * Bounds are copied from the app's `src/lib/v2-fee-tiers.ts` and `src/lib/v2-combinations.ts`.
+ * `feeModel` walks a stack exactly the way `src/lib/v2-fee-streams.ts`'s `buildV2FeeStreams`
+ * does — same streams, same order, same split arithmetic — restated in wei terms at a supplied
+ * sample amount (default one whole unit, 1e18) rather than the app's formatted, labelled rows.
+ * `src/test/hookr-sdk-parity.test.ts` calls both on the same three configurations and the same
+ * sample amount and asserts the wei splits agree.
+ */
+import { compileRuleBlocks } from "./rules.js";
+/** `HookrNativeMechanicsBlockV2.MAX_TOTAL_FEE_PIPS`: 50% of a swap, base + surge + snipe. */
+export const MAX_TOTAL_FEE_PIPS = 500_000;
+/** Smallest base fee accepted. One pip is a millionth; 100 pips is 0.01%. */
+export const MIN_BASE_FEE_PIPS = 100;
+/** The base fee's admissible range, in pips. */
+export const baseFeeBounds = Object.freeze({
+    min: MIN_BASE_FEE_PIPS,
+    max: MAX_TOTAL_FEE_PIPS,
+});
+/** `HookrMarketCoordinatorV5.defaultProtocolShareBps`: the protocol's default share of each add-on. */
+export const DEFAULT_PROTOCOL_SHARE_BPS = 2_000;
+/** `HookrNativeMechanicsBlockV2.MAX_PROTOCOL_SHARE_BPS`: the hard ceiling on that share. */
+export const MAX_PROTOCOL_SHARE_BPS = 5_000;
+const BPS = 10000n;
+const PIPS = 1000000n;
+function pipsOf(pips, baseWei) {
+    return (baseWei * BigInt(Math.max(0, Math.round(pips)))) / PIPS;
+}
+function bpsOf(bps, baseWei) {
+    return (baseWei * BigInt(Math.max(0, Math.round(bps)))) / BPS;
+}
+/** A stream's total split into the recipient's share and the protocol's, per the fee model: the
+ *  protocol's share is always a floor of the total, never above the frozen rate. */
+function splitByShare(totalWei, protocolShareBps) {
+    const bounded = Math.max(0, Math.min(10_000, Math.round(protocolShareBps)));
+    const protocol = (totalWei * BigInt(bounded)) / BPS;
+    return { recipient: totalWei - protocol, protocol };
+}
+/**
+ * Walk a stack of rule blocks through the fee model for one sample amount, exactly as
+ * `buildV2FeeStreams` does: the base fee is always shown; surge, the snipe tax, the LP-reward
+ * and pot cuts, and the burn cut each appear only while their rule is on the stack with a
+ * nonzero rate. The snipe-tax row is shown as if the guard were open, because that is the only
+ * state in which it is ever nonzero — the app's row says so too.
+ *
+ * `baseFeePips` is the stack's Base LP fee (see `compileRuleBlocks`); `amountWei` defaults to
+ * one whole unit (1e18) of the pool's quote currency.
+ */
+export function feeModel(baseFeePips, blocks, opts = {}) {
+    const amountWei = opts.amountWei ?? 10n ** 18n;
+    const protocolShareBps = opts.protocolShareBps ?? DEFAULT_PROTOCOL_SHARE_BPS;
+    const compiled = compileRuleBlocks(blocks, baseFeePips);
+    const { maxFeePips, snipeTaxPips, lpBps, potBps, burnBps } = compiled;
+    const base = Math.max(0, compiled.baseFeePips);
+    // The gross LP-reward-plus-pot cut, exactly as the app's `buildBuyWaterfall` computes it with
+    // royaltyBps pinned to 0 (the same pinning `buildV2FeeStreams` uses): one bigint division of
+    // the sample amount by the combined cut, then split between the two rules by their own share
+    // of that combined cut — never re-derived from the amount separately, so the same rounding
+    // dust lands in the same place (the pot) that the app's walk does.
+    const totalCutBps = lpBps + potBps;
+    const grossCutWei = totalCutBps > 0 ? (amountWei * BigInt(totalCutBps)) / BPS : 0n;
+    const lpRewardTotalWei = totalCutBps > 0 ? (grossCutWei * BigInt(lpBps)) / BigInt(totalCutBps) : 0n;
+    const potTotalWei = grossCutWei - lpRewardTotalWei;
+    const baseWei = pipsOf(base, amountWei);
+    const surgeTotalWei = pipsOf(Math.max(0, maxFeePips - base), amountWei);
+    const snipeTotalWei = pipsOf(snipeTaxPips, amountWei);
+    const surgeSplit = splitByShare(surgeTotalWei, protocolShareBps);
+    const snipeSplit = splitByShare(snipeTotalWei, protocolShareBps);
+    const lpRewardSplit = splitByShare(lpRewardTotalWei, protocolShareBps);
+    const potSplit = splitByShare(potTotalWei, protocolShareBps);
+    const burnProtocolBps = Math.floor((burnBps * protocolShareBps) / 10_000);
+    const burnNetBps = burnBps - burnProtocolBps;
+    const burnProtocolWei = bpsOf(burnProtocolBps, amountWei);
+    const streams = [
+        {
+            stream: "baseFee",
+            rule: null,
+            totalWei: baseWei,
+            recipientWei: baseWei,
+            protocolWei: 0n,
+            burnNetBps: null,
+        },
+    ];
+    if (maxFeePips > base) {
+        streams.push({
+            stream: "surge",
+            rule: "fee",
+            totalWei: surgeTotalWei,
+            recipientWei: surgeSplit.recipient,
+            protocolWei: surgeSplit.protocol,
+            burnNetBps: null,
+        });
+    }
+    if (snipeTaxPips > 0) {
+        streams.push({
+            stream: "snipeTax",
+            rule: "snipe",
+            totalWei: snipeTotalWei,
+            recipientWei: snipeSplit.recipient,
+            protocolWei: snipeSplit.protocol,
+            burnNetBps: null,
+        });
+    }
+    if (lpBps > 0) {
+        streams.push({
+            stream: "lpReward",
+            rule: "lp",
+            totalWei: lpRewardTotalWei,
+            recipientWei: lpRewardSplit.recipient,
+            protocolWei: lpRewardSplit.protocol,
+            burnNetBps: null,
+        });
+    }
+    if (potBps > 0) {
+        streams.push({
+            stream: "pot",
+            rule: "pot",
+            totalWei: potTotalWei,
+            recipientWei: potSplit.recipient,
+            protocolWei: potSplit.protocol,
+            burnNetBps: null,
+        });
+    }
+    if (burnBps > 0) {
+        streams.push({
+            stream: "burn",
+            rule: "burn",
+            totalWei: burnProtocolWei,
+            recipientWei: 0n,
+            protocolWei: burnProtocolWei,
+            burnNetBps,
+        });
+    }
+    const totalProtocolWei = surgeSplit.protocol + snipeSplit.protocol + lpRewardSplit.protocol + potSplit.protocol + burnProtocolWei;
+    return Object.freeze({
+        amountWei,
+        protocolShareBps,
+        streams: Object.freeze(streams),
+        totalProtocolWei,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * `@hookr/sdk` — build a market on Hookr's one live root hook with a custom rule configuration,
+ * quote and swap through Hookr's router, read markets, and claim payouts.
+ *
+ * There is exactly one root today: `HookrModularHookV6` on Robinhood Chain (id 4663),
+ * `ADDRESSES.root` in `chain.ts`. See the README for a quickstart.
+ */
+export * from "./chain.js";
+export * from "./abi.js";
+export * from "./rules.js";
+export * from "./fees.js";
+export * from "./market.js";
+export * from "./swap.js";
+export * from "./reads.js";
+export * from "./claims.js";
+export * from "./links.js";

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * `@hookr/sdk` — build a market on Hookr's one live root hook with a custom rule configuration,
+ * quote and swap through Hookr's router, read markets, and claim payouts.
+ *
+ * There is exactly one root today: `HookrModularHookV6` on Robinhood Chain (id 4663),
+ * `ADDRESSES.root` in `chain.ts`. See the README for a quickstart.
+ */
+export * from "./chain.js";
+export * from "./abi.js";
+export * from "./rules.js";
+export * from "./fees.js";
+export * from "./market.js";
+export * from "./swap.js";
+export * from "./reads.js";
+export * from "./claims.js";
+export * from "./links.js";

package/dist/links.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Deep links into Hookr's builder, in the app's "remix" wire format.
+ *
+ * Copied from `src/lib/remix.ts` in the app (`encodeStack`, `decodeStack`,
+ * `decodeStackBaseFeePips`): one segment per rule, values in `PARAMS[type]` key order, plus an
+ * optional trailing `base:<percent>` segment for the stack's Base LP fee — written only when it
+ * differs from the launchpad's immutable default, so a link encoded before that segment existed
+ * keeps decoding exactly as it always did. `src/test/hookr-sdk-parity.test.ts` asserts this
+ * module's `encodeStack`/`decodeStack` round-trip through the app's own functions.
+ *
+ * The app hydrates a `?stack=`/`?from=` link on its `/builder` route only (`decodeRemix`, read
+ * there); there is no separate "ready to launch" page that accepts one yet. `launchLink` and
+ * `builderLink` both resolve to that one route today for that reason — kept as two names so a
+ * caller can use whichever fits its own UI, and so this package does not need to change if the
+ * app ever does split them.
+ */
+import type { Address } from "viem";
+import { type RuleBlock } from "./rules.js";
+/** `hooks-model.ts`'s `DEFAULT_BASE_FEE_PIPS`: 0.3%, the launchpad's immutable default. */
+export declare const DEFAULT_BASE_FEE_PIPS = 3000;
+export declare const DEFAULT_ORIGIN = "https://hookr.fun";
+/** `stack:` value for a set of rule blocks and an optional stack-level Base LP fee (pips). */
+export declare function encodeStack(blocks: readonly RuleBlock[], baseFeePips?: number): string;
+/**
+ * Parse a `stack:` value. Null when nothing usable is present. Every parameter is clamped to
+ * its rule's bounds — a remix is a starting point, not a replica.
+ */
+export declare function decodeStack(value: string | null | undefined): RuleBlock[] | null;
+/** The stack-level Base LP fee out of a `stack:` value, in pips. `DEFAULT_BASE_FEE_PIPS` when absent. */
+export declare function decodeStackBaseFeePips(value: string | null | undefined): number;
+export type LinkConfig = Readonly<{
+    blocks: readonly RuleBlock[];
+    /** The stack's Base LP fee, in pips. Omit to leave it at the launchpad default. */
+    baseFeePips?: number;
+}>;
+export type LinkOptions = Readonly<{
+    /** Defaults to `https://hookr.fun`. */
+    origin?: string;
+    /** The token this configuration was copied from, for the "from" query param. */
+    from?: Address;
+}>;
+/** A link into Hookr's builder with this configuration pre-loaded, for exploring or tweaking it. */
+export declare function builderLink(config: LinkConfig, opts?: LinkOptions): string;
+/**
+ * A link into Hookr to open a market with this configuration. Resolves to the same `/builder`
+ * route as `builderLink` today — see the module doc.
+ */
+export declare function launchLink(config: LinkConfig, opts?: LinkOptions): string;

package/dist/links.js

@@ -0,0 +1,93 @@
+import { MAX_TOTAL_FEE_PIPS, MIN_BASE_FEE_PIPS } from "./fees.js";
+import { PARAMS, RULE_ORDER } from "./rules.js";
+/** `hooks-model.ts`'s `DEFAULT_BASE_FEE_PIPS`: 0.3%, the launchpad's immutable default. */
+export const DEFAULT_BASE_FEE_PIPS = 3_000;
+export const DEFAULT_ORIGIN = "https://hookr.fun";
+const BASE_FEE_SEGMENT = "base";
+function trimNumber(value) {
+    if (!Number.isFinite(value))
+        return "0";
+    return String(Number(value.toPrecision(12)));
+}
+function isRuleKey(value) {
+    return RULE_ORDER.includes(value);
+}
+/** `stack:` value for a set of rule blocks and an optional stack-level Base LP fee (pips). */
+export function encodeStack(blocks, baseFeePips) {
+    const blockSegments = blocks.map((block) => {
+        const values = PARAMS[block.type].map((spec) => trimNumber(block.params[spec.key] ?? spec.def));
+        return `${block.type}:${values.join(",")}`;
+    });
+    const segments = baseFeePips !== undefined && Math.round(baseFeePips) !== DEFAULT_BASE_FEE_PIPS
+        ? [...blockSegments, `${BASE_FEE_SEGMENT}:${trimNumber(baseFeePips / 10_000)}`]
+        : blockSegments;
+    return segments.join("|");
+}
+/**
+ * Parse a `stack:` value. Null when nothing usable is present. Every parameter is clamped to
+ * its rule's bounds — a remix is a starting point, not a replica.
+ */
+export function decodeStack(value) {
+    if (!value)
+        return null;
+    const blocks = [];
+    const seen = new Set();
+    let sawBaseFeeSegment = false;
+    for (const segment of value.split("|")) {
+        const [type, list] = segment.split(":");
+        if (type === BASE_FEE_SEGMENT) {
+            sawBaseFeeSegment = true;
+            continue;
+        }
+        if (!type || !isRuleKey(type) || seen.has(type))
+            continue;
+        const specs = PARAMS[type];
+        const parts = (list ?? "").split(",");
+        const params = {};
+        specs.forEach((spec, i) => {
+            const parsed = Number(parts[i]);
+            const v = Number.isFinite(parsed) ? parsed : spec.def;
+            params[spec.key] = Math.min(spec.max, Math.max(spec.min, v));
+        });
+        seen.add(type);
+        blocks.push({ type, params: Object.freeze(params) });
+    }
+    return blocks.length > 0 || sawBaseFeeSegment ? blocks : null;
+}
+/** The stack-level Base LP fee out of a `stack:` value, in pips. `DEFAULT_BASE_FEE_PIPS` when absent. */
+export function decodeStackBaseFeePips(value) {
+    if (!value)
+        return DEFAULT_BASE_FEE_PIPS;
+    for (const segment of value.split("|")) {
+        const [type, list] = segment.split(":");
+        if (type !== BASE_FEE_SEGMENT)
+            continue;
+        const parsed = Number(list);
+        if (!Number.isFinite(parsed))
+            continue;
+        const pips = Math.round(parsed * 10_000);
+        return Math.min(MAX_TOTAL_FEE_PIPS, Math.max(MIN_BASE_FEE_PIPS, pips));
+    }
+    return DEFAULT_BASE_FEE_PIPS;
+}
+function stackHref(path, config, opts = {}) {
+    const stack = encodeStack(config.blocks, config.baseFeePips);
+    const query = new URLSearchParams();
+    if (stack)
+        query.set("stack", stack);
+    if (opts.from)
+        query.set("from", opts.from);
+    const qs = query.toString();
+    return `${opts.origin ?? DEFAULT_ORIGIN}${path}${qs ? `?${qs}` : ""}`;
+}
+/** A link into Hookr's builder with this configuration pre-loaded, for exploring or tweaking it. */
+export function builderLink(config, opts) {
+    return stackHref("/builder", config, opts);
+}
+/**
+ * A link into Hookr to open a market with this configuration. Resolves to the same `/builder`
+ * route as `builderLink` today — see the module doc.
+ */
+export function launchLink(config, opts) {
+    return stackHref("/builder", config, opts);
+}