hookr-sdk 0.1.0

package/dist/reads.js

@@ -0,0 +1,140 @@
+/**
+ * Read a market from the coordinator, list markets from `MarketCreated` logs, and read a pool's
+ * frozen rules from the stack registry.
+ *
+ * `readMarket` mirrors `HookrMarketCoordinatorV5.getMarket`; `listMarkets` mirrors the log shape
+ * and scan-from block in the app's `src/lib/v2-discover-server.ts` (`v2MarketRowFromLog`,
+ * `V2_MARKET_SCAN_FROM_BLOCK`); `readPoolRules` mirrors the registry read the app's agent skill
+ * (`src/lib/agent-skill.ts`, "Read a pool's rules") describes in prose: `stack(poolId)` for the
+ * module count and limits, then `moduleAt(poolId, i)` for each module, decoding the
+ * native-mechanics module's `config` with `market.ts`'s `NativeConfig` tuple.
+ */
+import { decodeAbiParameters, getAbiItem, toEventSelector } from "viem";
+import { hookrMarketCoordinatorV5Abi, hookrStackRegistryV2Abi } from "./abi.js";
+import { ADDRESSES, MODULE_ID } from "./chain.js";
+function marketOrigin(value) {
+    if (value === 1)
+        return "new-token";
+    if (value === 2)
+        return "existing-token";
+    throw new Error(`Unknown MarketOrigin ${value}.`);
+}
+/** `marketCoordinator.getMarket(poolId)`. `live` is false for a `poolId` the coordinator never opened. */
+export async function readMarket(client, poolId) {
+    const m = (await client.readContract({
+        address: ADDRESSES.coordinator,
+        abi: hookrMarketCoordinatorV5Abi,
+        functionName: "getMarket",
+        args: [poolId],
+    }));
+    return Object.freeze({ ...m, origin: marketOrigin(m.origin) });
+}
+// -----------------------------------------------------------------------------------------------
+// listMarkets
+// -----------------------------------------------------------------------------------------------
+/** The coordinator's deploy block on chain 4663: no `MarketCreated` log can sit before it. */
+export const MARKET_SCAN_FROM_BLOCK = 57229676n;
+const MARKET_CREATED_EVENT = getAbiItem({ abi: hookrMarketCoordinatorV5Abi, name: "MarketCreated" });
+export const MARKET_CREATED_TOPIC = toEventSelector(MARKET_CREATED_EVENT);
+/**
+ * Every `MarketCreated` log the coordinator emitted in `[fromBlock, toBlock]`, oldest first.
+ *
+ * `root`, when given, is checked against every row's `kernel` rather than passed to the log
+ * filter: `kernel` is not an indexed topic, and there is exactly one live root today
+ * (`ADDRESSES.root`), so every row already carries it. A future second root would need a
+ * client-side filter here, which is exactly what this parameter is for.
+ */
+export async function listMarkets(client, options = {}) {
+    const fromBlock = options.fromBlock ?? MARKET_SCAN_FROM_BLOCK;
+    const toBlock = options.toBlock ?? (await client.getBlockNumber());
+    const logs = await client.getLogs({
+        address: ADDRESSES.coordinator,
+        event: MARKET_CREATED_EVENT,
+        fromBlock,
+        toBlock,
+        strict: true,
+    });
+    const rows = [];
+    for (const log of logs) {
+        const args = log.args;
+        const row = Object.freeze({
+            poolId: args.poolId,
+            subject: args.subject,
+            quote: args.quote,
+            creator: args.creator,
+            origin: marketOrigin(args.origin),
+            kernel: args.kernel,
+            sqrtPriceX96: args.sqrtPriceX96,
+            tickSpacing: args.tickSpacing,
+            blockNumber: log.blockNumber,
+            txHash: log.transactionHash,
+            logIndex: log.logIndex ?? 0,
+        });
+        if (options.root && row.kernel.toLowerCase() !== options.root.toLowerCase())
+            continue;
+        rows.push(row);
+    }
+    rows.sort((a, b) => (a.blockNumber === b.blockNumber ? a.logIndex - b.logIndex : a.blockNumber < b.blockNumber ? -1 : 1));
+    return Object.freeze(rows);
+}
+// -----------------------------------------------------------------------------------------------
+// readPoolRules
+// -----------------------------------------------------------------------------------------------
+const CONFIG_COMPONENTS = [
+    { name: "poolId", type: "bytes32" },
+    { name: "kernel", type: "address" },
+    { name: "subject", type: "address" },
+    { name: "quote", type: "address" },
+    { name: "lockedLiquidityProvider", type: "address" },
+    { name: "guardEndBlock", type: "uint40" },
+    { name: "baseFeePips", type: "uint24" },
+    { name: "maxFeePips", type: "uint24" },
+    { name: "snipeTaxPips", type: "uint24" },
+    { name: "surgeSens", type: "uint16" },
+    { name: "burnBps", type: "uint16" },
+    { name: "lpBps", type: "uint16" },
+    { name: "potBps", type: "uint16" },
+    { name: "royaltyBps", type: "uint16" },
+    { name: "potEveryNBuys", type: "uint32" },
+    { name: "maxBuyQuoteAmount", type: "uint96" },
+    { name: "potMinBuyWei", type: "uint96" },
+    { name: "royaltyTo", type: "address" },
+    { name: "protocolRecipient", type: "address" },
+    { name: "protocolShareBps", type: "uint24" },
+];
+const CONFIG_ABI = [{ type: "tuple", components: CONFIG_COMPONENTS }];
+/** The inverse of `market.ts`'s `encodeNativeBlockConfig`. */
+export function decodeNativeBlockConfig(data) {
+    const raw = decodeAbiParameters(CONFIG_ABI, data)[0];
+    return Object.freeze({ ...raw, guardEndBlock: BigInt(raw.guardEndBlock) });
+}
+/**
+ * `stackRegistry.stack(poolId)` for `moduleCount`/`limits`, then `stackRegistry.moduleAt` for
+ * each module, decoding the native-mechanics module's `config` bytes. Every other module (the
+ * directional tax block, when a pool carries one) is skipped: its config schema is not modeled
+ * by this package.
+ */
+export async function readPoolRules(client, poolId) {
+    const core = (await client.readContract({
+        address: ADDRESSES.registry,
+        abi: hookrStackRegistryV2Abi,
+        functionName: "stack",
+        args: [poolId],
+    }));
+    if (!core.configured)
+        return Object.freeze({ configured: false, limits: null, nativeConfig: null });
+    let nativeConfig = null;
+    for (let i = 0; i < core.moduleCount; i++) {
+        const [snapshot, config] = (await client.readContract({
+            address: ADDRESSES.registry,
+            abi: hookrStackRegistryV2Abi,
+            functionName: "moduleAt",
+            args: [poolId, BigInt(i)],
+        }));
+        if (snapshot.moduleId.toLowerCase() === MODULE_ID.toLowerCase()) {
+            nativeConfig = decodeNativeBlockConfig(config);
+            break;
+        }
+    }
+    return Object.freeze({ configured: true, limits: core.limits, nativeConfig });
+}

package/dist/rules.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The public rules a market's stack can carry, and their bounds.
+ *
+ * Copied from the Hookr app's `src/lib/hooks-model.ts`: `RULES` mirrors `HOOKS` reduced to
+ * `{ key, name, summary, explanation }`, and `PARAMS` mirrors the bounds/step/default of the
+ * app's `PARAMS[type]` (its display-only `fmt` function is not carried here; `unit` is a short,
+ * human label instead — see the module doc below). Both are restricted to the app's
+ * `PUBLIC_BUILDER_HOOK_ORDER`, which today is the five deployed blocks (`HOOK_ORDER`): the
+ * directional tax module (`DIRECTIONAL_TAX_UI` in the app) is off and is not offered here either.
+ * `src/test/hookr-sdk-parity.test.ts` in the app asserts the key order and every bound match.
+ *
+ * A rule compiles into the native block's `Config` (see `fees.ts` and `market.ts`); it is not a
+ * separate contract call. At most five rules on a stack today, one per key, because there are
+ * only five public rule keys — `validateStack` still checks the count explicitly so a future
+ * sixth key does not silently raise the ceiling.
+ */
+export type RuleKey = "snipe" | "fee" | "burn" | "lp" | "pot";
+/** The public rule keys, in the order the app's builder palette offers them. */
+export declare const RULE_ORDER: readonly RuleKey[];
+export type Rule = Readonly<{
+    key: RuleKey;
+    name: string;
+    /** Compact catalogue tagline. */
+    summary: string;
+    /** One complete, plain-language sentence. */
+    explanation: string;
+}>;
+export declare const RULES: readonly Rule[];
+export declare function ruleFor(key: RuleKey): Rule;
+export type Param = Readonly<{
+    key: string;
+    label: string;
+    min: number;
+    max: number;
+    step: number;
+    def: number;
+    /** Short display unit, e.g. "%", "BLK", "ETH". Display-only; not asserted byte-for-byte
+     *  against the app's `fmt` function, which the app keeps as a closure, not exported data. */
+    unit: string;
+    hint: string;
+}>;
+export declare const PARAMS: Readonly<Record<RuleKey, readonly Param[]>>;
+export type RuleBlock = Readonly<{
+    type: RuleKey;
+    params: Readonly<Record<string, number>>;
+}>;
+/** The native block's `Config` rate fields a stack of rule blocks compiles into. */
+export type CompiledRules = Readonly<{
+    guardBlocks: number;
+    maxBuyBps: number;
+    snipeTaxPips: number;
+    baseFeePips: number;
+    maxFeePips: number;
+    surgeSens: number;
+    burnBps: number;
+    lpBps: number;
+    potBps: number;
+    potEveryNBuys: number;
+    potMinBuyWei: bigint;
+}>;
+/**
+ * Compile a stack of public rule blocks into the exact rate fields the native block's `Config`
+ * carries, mirroring `compileStack` in the app's `src/lib/hooks-model.ts`.
+ *
+ * `baseFeePipsOverride` is the stack-level Base LP fee, chosen independently of whether a
+ * Surge Fees rule is present — it always wins over the Surge block's own "Base fee" slider,
+ * exactly like the app's builder. The block still supplies the surge ceiling and sensitivity.
+ */
+export declare function compileRuleBlocks(blocks: readonly RuleBlock[], baseFeePipsOverride: number): CompiledRules;
+/** The default single block for one rule: every param at its `def`. */
+export declare function defaultBlock(key: RuleKey): RuleBlock;
+/** The starting stack a new configuration opens with: no rules, base fee only. */
+export declare function defaultStack(): readonly RuleBlock[];
+export declare const MAX_STACK_RULES = 5;
+export type ValidationResult = Readonly<{
+    ok: boolean;
+    errors: readonly string[];
+}>;
+/**
+ * Validate a stack of rule blocks: unknown rule keys, duplicate rules, more than
+ * `MAX_STACK_RULES` rules, an unknown parameter, or a parameter outside its bounds or off its
+ * step grid. Every problem is reported, not just the first.
+ */
+export declare function validateStack(blocks: readonly RuleBlock[]): ValidationResult;

package/dist/rules.js

@@ -0,0 +1,296 @@
+/**
+ * The public rules a market's stack can carry, and their bounds.
+ *
+ * Copied from the Hookr app's `src/lib/hooks-model.ts`: `RULES` mirrors `HOOKS` reduced to
+ * `{ key, name, summary, explanation }`, and `PARAMS` mirrors the bounds/step/default of the
+ * app's `PARAMS[type]` (its display-only `fmt` function is not carried here; `unit` is a short,
+ * human label instead — see the module doc below). Both are restricted to the app's
+ * `PUBLIC_BUILDER_HOOK_ORDER`, which today is the five deployed blocks (`HOOK_ORDER`): the
+ * directional tax module (`DIRECTIONAL_TAX_UI` in the app) is off and is not offered here either.
+ * `src/test/hookr-sdk-parity.test.ts` in the app asserts the key order and every bound match.
+ *
+ * A rule compiles into the native block's `Config` (see `fees.ts` and `market.ts`); it is not a
+ * separate contract call. At most five rules on a stack today, one per key, because there are
+ * only five public rule keys — `validateStack` still checks the count explicitly so a future
+ * sixth key does not silently raise the ceiling.
+ */
+/** The public rule keys, in the order the app's builder palette offers them. */
+export const RULE_ORDER = ["snipe", "fee", "burn", "lp", "pot"];
+export const RULES = Object.freeze([
+    Object.freeze({
+        key: "snipe",
+        name: "Anti-Snipe",
+        summary: "Caps early buys and adds an LP fee in the first blocks",
+        explanation: "It caps total ETH bought per pool block and adds an extra LP fee during a fixed opening window.",
+    }),
+    Object.freeze({
+        key: "fee",
+        name: "Surge Fees",
+        summary: "Fee scales with trade size",
+        explanation: "It raises the LP fee from a base rate toward a ceiling as trade size grows relative to in-range depth.",
+    }),
+    Object.freeze({
+        key: "burn",
+        name: "Auto Burn",
+        summary: "Burns a share of actual buy output",
+        explanation: "It sends a chosen share of each exact-input buy's token output directly to the dead address.",
+    }),
+    Object.freeze({
+        key: "lp",
+        name: "LP Rewards",
+        summary: "Fee share streams to LPs",
+        explanation: "It donates an ETH-side share of each exact-input buy to liquidity positions that are in range.",
+    }),
+    Object.freeze({
+        key: "pot",
+        name: "Nth-buy Pot",
+        summary: "A public counter pays every Nth buy",
+        explanation: "It fills a deterministic pot from exact-input buys and pays it to the recipient of every Nth qualifying buy.",
+    }),
+]);
+const RULES_BY_KEY = Object.freeze(Object.fromEntries(RULES.map((rule) => [rule.key, rule])));
+export function ruleFor(key) {
+    return RULES_BY_KEY[key];
+}
+export const PARAMS = Object.freeze({
+    snipe: Object.freeze([
+        Object.freeze({
+            key: "guard",
+            label: "Guard window",
+            min: 5,
+            max: 500,
+            step: 5,
+            def: 100,
+            unit: "BLK",
+            hint: "Blocks after the pool opens with sniper protection active. Counted in the parent-chain blocks the contracts see (~12 s each), not this chain's ~0.1 s blocks, so 100 is roughly 20 minutes.",
+        }),
+        Object.freeze({
+            key: "maxbuy",
+            label: "Max buy",
+            min: 0.1,
+            max: 5,
+            step: 0.1,
+            def: 0.5,
+            unit: "%",
+            hint: "Cumulative cap on all buys in one pool block during the guard window, derived from a share of the launch's supply basis. Splitting one order does not create more room in that block.",
+        }),
+        Object.freeze({
+            key: "tax",
+            label: "Snipe tax",
+            min: 0,
+            max: 45,
+            step: 5,
+            def: 40,
+            unit: "%",
+            hint: "Extra LP fee on swaps inside the guard window. Goes to LPs.",
+        }),
+    ]),
+    fee: Object.freeze([
+        Object.freeze({
+            key: "base",
+            label: "Base fee",
+            min: 0.05,
+            max: 1,
+            step: 0.05,
+            def: 0.3,
+            unit: "%",
+            hint: "Swap fee when the pool is calm.",
+        }),
+        Object.freeze({
+            key: "max",
+            label: "Max fee",
+            min: 1,
+            max: 10,
+            step: 0.5,
+            def: 3,
+            unit: "%",
+            hint: "Ceiling for large trades relative to pool depth.",
+        }),
+        Object.freeze({
+            key: "sens",
+            label: "Size sensitivity",
+            min: 1,
+            max: 10,
+            step: 1,
+            def: 5,
+            unit: "X",
+            hint: "How fast the fee ramps as a trade eats the pool.",
+        }),
+    ]),
+    burn: Object.freeze([
+        Object.freeze({
+            key: "cut",
+            label: "Output burn",
+            min: 0.1,
+            max: 5,
+            step: 0.1,
+            def: 1,
+            unit: "% OUT",
+            hint: "Share of the actual token output sent directly to the dead address on each exact-input buy. No ETH vault or market buy.",
+        }),
+    ]),
+    lp: Object.freeze([
+        Object.freeze({
+            key: "share",
+            label: "LP fee share",
+            min: 0.05,
+            max: 1,
+            step: 0.05,
+            def: 0.25,
+            unit: "%",
+            hint: "Slice of each buy donated to in-range LPs.",
+        }),
+    ]),
+    pot: Object.freeze([
+        Object.freeze({
+            key: "cut",
+            label: "Pot share",
+            min: 0.1,
+            max: 2,
+            step: 0.1,
+            def: 0.5,
+            unit: "% SWAP",
+            hint: "Share of every exact-input buy added to the deterministic pot.",
+        }),
+        Object.freeze({
+            key: "every",
+            label: "Pays every N buys",
+            min: 100,
+            max: 5000,
+            step: 100,
+            def: 500,
+            unit: "buys",
+            hint: "The public counter advances at most once per pool per block. The Nth qualifying buy wins; this is not random.",
+        }),
+        Object.freeze({
+            key: "minbuy",
+            label: "Min qualifying buy",
+            min: 0.001,
+            max: 1,
+            step: 0.001,
+            def: 0.01,
+            unit: "ETH",
+            hint: "Buys below this cannot advance the public pot counter.",
+        }),
+    ]),
+});
+/** `eth` -> wei at fixed 9-decimal precision, matching the app's `toWei` (avoids float drift). */
+function toWei(eth) {
+    return BigInt(Math.round(eth * 1e9)) * 10n ** 9n;
+}
+/**
+ * Compile a stack of public rule blocks into the exact rate fields the native block's `Config`
+ * carries, mirroring `compileStack` in the app's `src/lib/hooks-model.ts`.
+ *
+ * `baseFeePipsOverride` is the stack-level Base LP fee, chosen independently of whether a
+ * Surge Fees rule is present — it always wins over the Surge block's own "Base fee" slider,
+ * exactly like the app's builder. The block still supplies the surge ceiling and sensitivity.
+ */
+export function compileRuleBlocks(blocks, baseFeePipsOverride) {
+    const baseFeePips = Math.round(baseFeePipsOverride);
+    const out = {
+        guardBlocks: 0,
+        maxBuyBps: 0,
+        snipeTaxPips: 0,
+        baseFeePips,
+        maxFeePips: baseFeePips,
+        surgeSens: 0,
+        burnBps: 0,
+        lpBps: 0,
+        potBps: 0,
+        potEveryNBuys: 0,
+        potMinBuyWei: 0n,
+    };
+    for (const block of blocks) {
+        const p = block.params;
+        if (block.type === "snipe") {
+            out.guardBlocks = Math.round(p.guard);
+            out.maxBuyBps = Math.round(p.maxbuy * 100);
+            out.snipeTaxPips = Math.round(p.tax * 10_000);
+        }
+        if (block.type === "fee") {
+            out.maxFeePips = Math.round(p.max * 10_000);
+            out.surgeSens = Math.round(p.sens);
+        }
+        if (block.type === "burn") {
+            out.burnBps = Math.round(p.cut * 100);
+        }
+        if (block.type === "lp") {
+            out.lpBps = Math.round(p.share * 100);
+        }
+        if (block.type === "pot") {
+            out.potBps = Math.round(p.cut * 100);
+            out.potEveryNBuys = Math.round(p.every);
+            out.potMinBuyWei = toWei(p.minbuy);
+        }
+    }
+    if (out.maxFeePips < out.baseFeePips)
+        out.maxFeePips = out.baseFeePips;
+    return Object.freeze(out);
+}
+/** The default single block for one rule: every param at its `def`. */
+export function defaultBlock(key) {
+    const params = {};
+    for (const spec of PARAMS[key])
+        params[spec.key] = spec.def;
+    return Object.freeze({ type: key, params: Object.freeze(params) });
+}
+/** The starting stack a new configuration opens with: no rules, base fee only. */
+export function defaultStack() {
+    return Object.freeze([]);
+}
+export const MAX_STACK_RULES = 5;
+/** Whether `value` sits on `spec`'s step grid, within floating-point rounding. */
+function onStep(value, spec) {
+    const steps = (value - spec.min) / spec.step;
+    return Math.abs(steps - Math.round(steps)) < 1e-9;
+}
+/**
+ * Validate a stack of rule blocks: unknown rule keys, duplicate rules, more than
+ * `MAX_STACK_RULES` rules, an unknown parameter, or a parameter outside its bounds or off its
+ * step grid. Every problem is reported, not just the first.
+ */
+export function validateStack(blocks) {
+    const errors = [];
+    if (blocks.length > MAX_STACK_RULES) {
+        errors.push(`A stack may carry at most ${MAX_STACK_RULES} rules; this one carries ${blocks.length}.`);
+    }
+    const seen = new Set();
+    for (const block of blocks) {
+        if (seen.has(block.type)) {
+            errors.push(`Rule "${block.type}" appears more than once in the stack.`);
+            continue;
+        }
+        seen.add(block.type);
+        const specs = PARAMS[block.type];
+        if (!specs) {
+            errors.push(`Unknown rule "${block.type}".`);
+            continue;
+        }
+        const knownKeys = new Set(specs.map((spec) => spec.key));
+        for (const paramKey of Object.keys(block.params)) {
+            if (!knownKeys.has(paramKey)) {
+                errors.push(`Rule "${block.type}" has no parameter "${paramKey}".`);
+            }
+        }
+        for (const spec of specs) {
+            const value = block.params[spec.key];
+            if (value === undefined) {
+                errors.push(`Rule "${block.type}" is missing its "${spec.key}" parameter.`);
+                continue;
+            }
+            if (!Number.isFinite(value)) {
+                errors.push(`Rule "${block.type}"'s "${spec.key}" must be a finite number.`);
+                continue;
+            }
+            if (value < spec.min || value > spec.max) {
+                errors.push(`Rule "${block.type}"'s "${spec.key}" (${value}) must be between ${spec.min} and ${spec.max}.`);
+                continue;
+            }
+            if (!onStep(value, spec)) {
+                errors.push(`Rule "${block.type}"'s "${spec.key}" (${value}) must be a multiple of ${spec.step} from ${spec.min}.`);
+            }
+        }
+    }
+    return Object.freeze({ ok: errors.length === 0, errors: Object.freeze(errors) });
+}

package/dist/swap.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Quote and swap through Hookr's kernel router and quoter (chain 4663).
+ *
+ * Copied from the app's `src/lib/v2-swap.ts` (`v2ExactInputCall`, `v2ExactOutputCall`,
+ * `v2QuoteCall`): empty module data, the full-fill price limit in both directions, and native
+ * ETH sent as `value` exactly when the input currency is the zero address. A pool that carries
+ * any input cut (surge, guard, burn, LP reward or pot) rejects any other limit outright — see
+ * `market.ts`'s module doc for the fee model these cuts come from.
+ */
+import type { Address, ContractFunctionArgs, Hex, PublicClient } from "viem";
+import { hookrKernelRouterV3Abi } from "./abi.js";
+import type { PoolKey } from "./market.js";
+/** Router / block `MIN_SQRT_PRICE_LIMIT`: the full-fill limit for a `zeroForOne` swap. */
+export declare const MIN_SQRT_PRICE_LIMIT = 4295128740n;
+/** Router / block `MAX_SQRT_PRICE_LIMIT`: the full-fill limit for a `oneForZero` swap. */
+export declare const MAX_SQRT_PRICE_LIMIT = 1461446703485210103287273052203988822378723970341n;
+/** `type(int128).max`: the router's and the quoter's ceiling on every amount and bound. */
+export declare const INT128_MAX: bigint;
+/** The bound an exact-input quote carries: the smallest value the quoter admits. */
+export declare const QUOTE_MIN_OUT_BOUND = 1n;
+/** The router's `moduleData` for a plain swap: the native block reads none. */
+export declare const EMPTY_MODULE_DATA: Hex;
+/** The full-fill `sqrtPriceLimitX96`: `MIN` when selling currency0, `MAX` otherwise. Any pool
+ *  with an input cut rejects every other limit on an exact-input buy. */
+export declare function fullFillLimit(zeroForOne: boolean): bigint;
+/** `zeroForOne = currencyIn == key.currency0`. Throws when `currencyIn` is not in the pool. */
+export declare function swapDirection(key: PoolKey, currencyIn: Address): boolean;
+export type RouterCall<F extends "exactInput" | "exactOutput"> = Readonly<{
+    address: Address;
+    abi: typeof hookrKernelRouterV3Abi;
+    functionName: F;
+    args: ContractFunctionArgs<typeof hookrKernelRouterV3Abi, "payable", F>;
+    value: bigint;
+}>;
+/**
+ * `exactInput` through the Hookr router. `value` is `amountIn` when `currencyIn` is native ETH,
+ * else 0 (the router pulls the ERC-20 by `transferFrom`; approve it first).
+ */
+export declare function buildExactInputSwapCall(input: {
+    key: PoolKey;
+    currencyIn: Address;
+    amountIn: bigint;
+    amountOutMinimum: bigint;
+    recipient: Address;
+    deadline: bigint;
+}): RouterCall<"exactInput">;
+/**
+ * `exactOutput` through the Hookr router. `value` is `amountInMaximum` when `currencyIn` is
+ * native ETH — the router refunds what the swap does not use.
+ */
+export declare function buildExactOutputSwapCall(input: {
+    key: PoolKey;
+    currencyIn: Address;
+    amountOut: bigint;
+    amountInMaximum: bigint;
+    recipient: Address;
+    deadline: bigint;
+}): RouterCall<"exactOutput">;
+export type Quote = Readonly<{
+    amountIn: bigint;
+    amountOut: bigint;
+}>;
+/**
+ * Quote through `kernelQuoter.quote`. Run as a simulated call from `account` rather than an
+ * ordinary read: the function is declared `nonpayable` (it runs the full module loop, including
+ * the pot leg, which is recipient-specific), which is also why the app's own equivalent
+ * (`quoteV2` in `src/lib/v2-swap.ts`) calls `simulateContract` rather than `readContract` — the
+ * same `eth_call` either way, just the viem entry point whose types match a nonpayable function.
+ * `amountSpecified` is negative for an exact-input quote, bound at 1 wei/unit — the least the
+ * quoter admits; pass `amountBound` to override it (an exact-output quote wants `INT128_MAX` or
+ * your own maximum).
+ */
+export declare function quoteExactInput(client: PublicClient, input: {
+    key: PoolKey;
+    user: Address;
+    currencyIn: Address;
+    amountIn: bigint;
+    amountBound?: bigint;
+}): Promise<Quote>;