hookr-sdk 0.2.1 → 1.1.0

package/dist/rules.js

@@ -1,296 +0,0 @@
-/**
- * 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

@@ -1,108 +0,0 @@
-/**
- * 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";
-/**
- * The gas limit a swap on a correcting root must carry (the app's `CORRECTION_SWAP_GAS_FLOOR` in
- * `src/lib/gas-headroom.ts`). The recapture root runs its correction in both swap phases, once in
- * `beforeSwap` and again in `afterSwap` (`HookrSwapKernelV5Wth.sol`, `_tryCorrection` at lines 214
- * and 250), each inside a bounded call that fails open: a wallet's gas estimate covers the swap
- * alone, so an estimated transaction succeeds with the correction skipped and nothing recaptured.
- * The swap builders below put this floor on the call whenever `key.hooks` is the current recapture
- * root, or whenever the caller passes `correcting: true`; pass it through to `writeContract` (viem
- * sends `gas` as the limit) instead of estimating.
- */
-export declare const CORRECTION_SWAP_GAS_FLOOR = 1100000n;
-/**
- * True when `hooks` is the current recapture root, which corrects in both swap phases. This is the
- * root's identity, not the pool's: a pool opened on a superseded recapture root keeps the executor
- * frozen into its rules and keeps correcting, and this returns false for it. Read that from the
- * pool itself with `poolCorrects(await readPoolRules(client, poolId))` and pass the answer as
- * `correcting` to the swap builders.
- */
-export declare function isCorrectingRoot(hooks: Address): boolean;
-/** The gas limit to send with a swap on `key`: the floor when the pool corrects (`correcting`,
- *  defaulting to `isCorrectingRoot(key.hooks)`), else `undefined` (let the wallet estimate). */
-export declare function swapGasLimit(key: PoolKey, correcting?: boolean): bigint | undefined;
-/** 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;
-    /** Set to `CORRECTION_SWAP_GAS_FLOOR` when the pool corrects; absent otherwise. */
-    gas?: 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). `gas` carries the
- * correction floor when the pool corrects; send it as the gas limit. `correcting` defaults to
- * `isCorrectingRoot(key.hooks)`; pass `poolCorrects(rules)` for a pool on a superseded root.
- */
-export declare function buildExactInputSwapCall(input: {
-    key: PoolKey;
-    currencyIn: Address;
-    amountIn: bigint;
-    amountOutMinimum: bigint;
-    recipient: Address;
-    deadline: bigint;
-    correcting?: boolean;
-}): RouterCall<"exactInput">;
-/**
- * `exactOutput` through the Hookr router. `value` is `amountInMaximum` when `currencyIn` is
- * native ETH — the router refunds what the swap does not use. `correcting` works as on
- * `buildExactInputSwapCall`.
- */
-export declare function buildExactOutputSwapCall(input: {
-    key: PoolKey;
-    currencyIn: Address;
-    amountOut: bigint;
-    amountInMaximum: bigint;
-    recipient: Address;
-    deadline: bigint;
-    correcting?: boolean;
-}): 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>;

package/dist/swap.js

@@ -1,144 +0,0 @@
-import { hookrKernelQuoterV1Abi, hookrKernelRouterV3Abi } from "./abi.js";
-import { ADDRESSES, NATIVE_ADDRESS } from "./chain.js";
-/**
- * The gas limit a swap on a correcting root must carry (the app's `CORRECTION_SWAP_GAS_FLOOR` in
- * `src/lib/gas-headroom.ts`). The recapture root runs its correction in both swap phases, once in
- * `beforeSwap` and again in `afterSwap` (`HookrSwapKernelV5Wth.sol`, `_tryCorrection` at lines 214
- * and 250), each inside a bounded call that fails open: a wallet's gas estimate covers the swap
- * alone, so an estimated transaction succeeds with the correction skipped and nothing recaptured.
- * The swap builders below put this floor on the call whenever `key.hooks` is the current recapture
- * root, or whenever the caller passes `correcting: true`; pass it through to `writeContract` (viem
- * sends `gas` as the limit) instead of estimating.
- */
-export const CORRECTION_SWAP_GAS_FLOOR = 1100000n;
-/**
- * True when `hooks` is the current recapture root, which corrects in both swap phases. This is the
- * root's identity, not the pool's: a pool opened on a superseded recapture root keeps the executor
- * frozen into its rules and keeps correcting, and this returns false for it. Read that from the
- * pool itself with `poolCorrects(await readPoolRules(client, poolId))` and pass the answer as
- * `correcting` to the swap builders.
- */
-export function isCorrectingRoot(hooks) {
-    return hooks.toLowerCase() === ADDRESSES.recaptureRoot.toLowerCase();
-}
-/** The gas limit to send with a swap on `key`: the floor when the pool corrects (`correcting`,
- *  defaulting to `isCorrectingRoot(key.hooks)`), else `undefined` (let the wallet estimate). */
-export function swapGasLimit(key, correcting) {
-    return (correcting ?? isCorrectingRoot(key.hooks)) ? CORRECTION_SWAP_GAS_FLOOR : undefined;
-}
-/** Router / block `MIN_SQRT_PRICE_LIMIT`: the full-fill limit for a `zeroForOne` swap. */
-export const MIN_SQRT_PRICE_LIMIT = 4295128740n;
-/** Router / block `MAX_SQRT_PRICE_LIMIT`: the full-fill limit for a `oneForZero` swap. */
-export const MAX_SQRT_PRICE_LIMIT = 1461446703485210103287273052203988822378723970341n;
-/** `type(int128).max`: the router's and the quoter's ceiling on every amount and bound. */
-export const INT128_MAX = (1n << 127n) - 1n;
-/** The bound an exact-input quote carries: the smallest value the quoter admits. */
-export const QUOTE_MIN_OUT_BOUND = 1n;
-/** The router's `moduleData` for a plain swap: the native block reads none. */
-export const EMPTY_MODULE_DATA = "0x";
-/** 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 function fullFillLimit(zeroForOne) {
-    return zeroForOne ? MIN_SQRT_PRICE_LIMIT : MAX_SQRT_PRICE_LIMIT;
-}
-/** `zeroForOne = currencyIn == key.currency0`. Throws when `currencyIn` is not in the pool. */
-export function swapDirection(key, currencyIn) {
-    const same = (a, b) => a.toLowerCase() === b.toLowerCase();
-    if (same(currencyIn, key.currency0))
-        return true;
-    if (same(currencyIn, key.currency1))
-        return false;
-    throw new Error("That currency is not in this pool.");
-}
-/**
- * `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). `gas` carries the
- * correction floor when the pool corrects; send it as the gas limit. `correcting` defaults to
- * `isCorrectingRoot(key.hooks)`; pass `poolCorrects(rules)` for a pool on a superseded root.
- */
-export function buildExactInputSwapCall(input) {
-    const zeroForOne = swapDirection(input.key, input.currencyIn);
-    const native = input.currencyIn.toLowerCase() === NATIVE_ADDRESS.toLowerCase();
-    const gas = swapGasLimit(input.key, input.correcting);
-    return Object.freeze({
-        address: ADDRESSES.router,
-        abi: hookrKernelRouterV3Abi,
-        functionName: "exactInput",
-        args: [
-            {
-                key: input.key,
-                zeroForOne,
-                amountIn: input.amountIn,
-                amountOutMinimum: input.amountOutMinimum,
-                sqrtPriceLimitX96: fullFillLimit(zeroForOne),
-                recipient: input.recipient,
-                deadline: input.deadline,
-            },
-            EMPTY_MODULE_DATA,
-        ],
-        value: native ? input.amountIn : 0n,
-        ...(gas === undefined ? {} : { gas }),
-    });
-}
-/**
- * `exactOutput` through the Hookr router. `value` is `amountInMaximum` when `currencyIn` is
- * native ETH — the router refunds what the swap does not use. `correcting` works as on
- * `buildExactInputSwapCall`.
- */
-export function buildExactOutputSwapCall(input) {
-    const zeroForOne = swapDirection(input.key, input.currencyIn);
-    const native = input.currencyIn.toLowerCase() === NATIVE_ADDRESS.toLowerCase();
-    const gas = swapGasLimit(input.key, input.correcting);
-    return Object.freeze({
-        address: ADDRESSES.router,
-        abi: hookrKernelRouterV3Abi,
-        functionName: "exactOutput",
-        args: [
-            {
-                key: input.key,
-                zeroForOne,
-                amountOut: input.amountOut,
-                amountInMaximum: input.amountInMaximum,
-                sqrtPriceLimitX96: fullFillLimit(zeroForOne),
-                recipient: input.recipient,
-                deadline: input.deadline,
-            },
-            EMPTY_MODULE_DATA,
-        ],
-        value: native ? input.amountInMaximum : 0n,
-        ...(gas === undefined ? {} : { gas }),
-    });
-}
-/**
- * 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 async function quoteExactInput(client, input) {
-    const zeroForOne = swapDirection(input.key, input.currencyIn);
-    const { result } = await client.simulateContract({
-        address: ADDRESSES.quoter,
-        abi: hookrKernelQuoterV1Abi,
-        functionName: "quote",
-        account: input.user,
-        args: [
-            {
-                key: input.key,
-                payer: input.user,
-                recipient: input.user,
-                zeroForOne,
-                amountSpecified: -input.amountIn,
-                amountBound: input.amountBound ?? QUOTE_MIN_OUT_BOUND,
-                sqrtPriceLimitX96: fullFillLimit(zeroForOne),
-            },
-            EMPTY_MODULE_DATA,
-        ],
-    });
-    const [amountIn, amountOut] = result;
-    return Object.freeze({ amountIn, amountOut });
-}