@kestrelfi/lyc-sdk 1.0.1

package/dist/shared/jupiter-helpers/src/client.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JupiterSwapClient = void 0;
+const api_1 = require("./api");
+const extract_1 = require("./extract");
+const routePreInstructions_1 = require("./routePreInstructions");
+const constants_1 = require("./constants");
+const common_1 = require("common");
+/**
+ * Jupiter swap client implementing RoutableSwapClient (see `common`).
+ *
+ * Provides a simplified API for getting quotes and building swap instructions
+ * from Jupiter aggregator for use in CPI calls.
+ *
+ * @example
+ * ```typescript
+ * const client = new JupiterSwapClient(rpc);
+ *
+ * // Get a quote
+ * const quote = await client.getQuote({
+ *   inputMint: USDC_MINT,
+ *   outputMint: WSOL_MINT,
+ *   amount: 10_000_000, // 10 USDC
+ *   slippageBps: 500,   // 5%
+ * });
+ *
+ * // Build instruction for CPI
+ * const { data, accounts, programId } = await client.getSwapCpiData(
+ *   quote,
+ *   swapAuthorityPda
+ * );
+ *
+ * // Use in your Anchor program
+ * await program.methods
+ *   .executeSwap(Buffer.from(data))
+ *   .remainingAccounts(accounts.map(toWeb3AccountMeta))
+ *   .rpc();
+ * ```
+ */
+class JupiterSwapClient {
+    /**
+     * Creates a new Jupiter swap client.
+     *
+     * @param rpc - Solana RPC client for resolving address lookup tables
+     * @param config - Optional default quote policy applied to every Jupiter quote
+     */
+    constructor(rpc, config = {}) {
+        this.rpc = rpc;
+        this.config = config;
+        /**
+         * Empty lists mean any route for aggregate routing (Jupiter quotes arbitrary
+         * pairs via the API).
+         */
+        this.inputMints = [];
+        this.outputMints = [];
+        this.routeAnchorMints = [];
+    }
+    /**
+     * Get a swap quote from Jupiter.
+     *
+     * @param params - Quote parameters
+     * @returns Normalized swap quote with Jupiter's QuoteResponse as rawQuote
+     */
+    async getQuote(params) {
+        const excludeDexes = params.excludeDexes?.length
+            ? [...new Set([...(this.config.quoteDefaults?.excludeDexes ?? []), ...params.excludeDexes])]
+            : undefined;
+        const rawQuote = await (0, api_1.getJupiterQuote)({
+            ...(this.config.quoteDefaults ?? {}),
+            inputMint: params.inputMint,
+            outputMint: params.outputMint,
+            amount: params.amount,
+            slippageBps: params.slippageBps,
+            ...(params.maxAccounts !== undefined ? { maxAccounts: params.maxAccounts } : {}),
+            ...(params.onlyDirectRoutes !== undefined
+                ? { onlyDirectRoutes: params.onlyDirectRoutes }
+                : {}),
+            ...(excludeDexes ? { excludeDexes } : {}),
+        });
+        return {
+            inputMint: params.inputMint,
+            outputMint: params.outputMint,
+            inputAmount: BigInt(rawQuote.inAmount),
+            outputAmount: BigInt(rawQuote.outAmount),
+            priceImpactPct: Number(rawQuote.priceImpactPct ?? 0),
+            rawQuote,
+        };
+    }
+    /**
+     * Use Jupiter `ExactOut` quoting: desired output is `minOutputAmount`; reject if implied
+     * input exceeds `maxInputAmount`.
+     */
+    async getQuoteCoveringMinOutput(params) {
+        const need = params.minOutputAmount;
+        if (need <= BigInt(0)) {
+            throw new Error("getQuoteCoveringMinOutput: minOutputAmount must be positive");
+        }
+        const maxIn = params.maxInputAmount;
+        if (maxIn <= BigInt(0)) {
+            throw new Error("getQuoteCoveringMinOutput: maxInputAmount must be positive");
+        }
+        if (need > BigInt(Number.MAX_SAFE_INTEGER)) {
+            throw new Error("getQuoteCoveringMinOutput: minOutputAmount exceeds Number.MAX_SAFE_INTEGER");
+        }
+        const rawQuote = await (0, api_1.getJupiterQuote)({
+            ...(this.config.quoteDefaults ?? {}),
+            inputMint: params.inputMint,
+            outputMint: params.outputMint,
+            amount: Number(need),
+            slippageBps: params.slippageBps,
+            swapMode: "ExactOut",
+        });
+        const inAmt = BigInt(rawQuote.inAmount);
+        const outAmt = BigInt(rawQuote.outAmount);
+        if (inAmt > maxIn) {
+            throw new Error("Jupiter getQuoteCoveringMinOutput: exact-out route needs more input than maxInputAmount");
+        }
+        if (outAmt < need) {
+            throw new Error("Jupiter getQuoteCoveringMinOutput: quoted output is below minOutputAmount");
+        }
+        return {
+            inputMint: params.inputMint,
+            outputMint: params.outputMint,
+            inputAmount: inAmt,
+            outputAmount: outAmt,
+            priceImpactPct: Number(rawQuote.priceImpactPct ?? 0),
+            rawQuote,
+        };
+    }
+    /**
+     * Build Jupiter swap instruction for CPI.
+     *
+     * This fetches a swap transaction from Jupiter API, decompiles it,
+     * and extracts the instruction data and accounts needed for CPI.
+     *
+     * @param quote - Quote from getQuote()
+     * @param userPublicKey - Address executing the swap (typically a PDA)
+     * @param options - Swap options
+     * @returns Instruction data, accounts, and Jupiter program ID
+     */
+    async getSwapCpiData(quote, userPublicKey, options) {
+        const transaction = await (0, api_1.buildJupiterSwapTransaction)({
+            quote: quote.rawQuote,
+            userPublicKey,
+            wrapAndUnwrapSol: options?.wrapAndUnwrapSol ?? false,
+        });
+        const { data, accounts, lookupTables } = await (0, extract_1.extractJupiterInstruction)(transaction, this.rpc);
+        // When a `payer` is supplied we provision intermediate-mint ATAs for
+        // multi-hop routes; the swap authority `userPublicKey` is typically a PDA
+        // and can't pay the rent itself. With no payer we skip pre-instructions
+        // (single-hop routes don't need them; multi-hop routes will then fail
+        // at the CPI if intermediate ATAs are missing).
+        let preInstructions;
+        let preInvalidations;
+        if (options?.payer) {
+            const result = await (0, routePreInstructions_1.getJupiterRoutePreInstructions)(this.rpc, quote.rawQuote, userPublicKey, options.payer);
+            if (result.instructions.length) {
+                preInstructions = result.instructions;
+                preInvalidations = result.postSuccessCacheInvalidations;
+            }
+        }
+        return {
+            cpiType: common_1.CpiTypes.JUPITER_SWAP,
+            data,
+            accounts,
+            programId: constants_1.JUPITER_V6_PROGRAM_ID,
+            lookupTables,
+            ...(preInstructions ? { preInstructions } : {}),
+            ...(preInvalidations ? { postSuccessCacheInvalidations: preInvalidations } : {}),
+        };
+    }
+}
+exports.JupiterSwapClient = JupiterSwapClient;

package/dist/shared/jupiter-helpers/src/constants.d.ts

@@ -0,0 +1,35 @@
+import { type Address } from "@solana/kit";
+/**
+ * Jupiter V6 Aggregator Program ID
+ */
+export declare const JUPITER_V6_PROGRAM_ID: Address;
+/**
+ * Jupiter API base URL
+ */
+export declare const JUPITER_API_URL = "https://lite-api.jup.ag";
+/**
+ * Default slippage in basis points (5%)
+ */
+export declare const DEFAULT_SLIPPAGE_BPS = 500;
+/**
+ * Local/Surfpool max account budget for swap instructions.
+ * Lower values improve compatibility with local validators.
+ */
+export declare const LOCAL_TEST_MAX_ACCOUNTS = 20;
+/**
+ * DEXes to exclude in local/Surfpool tests.
+ * Production/testnet deployments should not apply this list by default.
+ */
+export declare const LOCAL_TEST_EXCLUDED_DEXES: string[];
+/**
+ * Venues excluded from ALL Jupiter quotes, in every environment. These
+ * proprietary market-maker venues rotate their vault token accounts
+ * off-chain, so quoted routes intermittently fail at execution with
+ * "Token account ... has wrong owner". Not applied when a `dexes`
+ * whitelist is set (the whitelist takes full control of routing).
+ *
+ * TODO(2026-07-06): Riptide was excluded after repeated wrong-owner failures
+ * on PYUSD routes. It often quotes the best stable-pair price, so revisit
+ * later and give it another chance if their account rotation has stabilized.
+ */
+export declare const ALWAYS_EXCLUDED_DEXES: string[];

package/dist/shared/jupiter-helpers/src/constants.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALWAYS_EXCLUDED_DEXES = exports.LOCAL_TEST_EXCLUDED_DEXES = exports.LOCAL_TEST_MAX_ACCOUNTS = exports.DEFAULT_SLIPPAGE_BPS = exports.JUPITER_API_URL = exports.JUPITER_V6_PROGRAM_ID = void 0;
+const kit_1 = require("@solana/kit");
+/**
+ * Jupiter V6 Aggregator Program ID
+ */
+exports.JUPITER_V6_PROGRAM_ID = (0, kit_1.address)("JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4");
+/**
+ * Jupiter API base URL
+ */
+exports.JUPITER_API_URL = "https://lite-api.jup.ag";
+/**
+ * Default slippage in basis points (5%)
+ */
+exports.DEFAULT_SLIPPAGE_BPS = 500;
+/**
+ * Local/Surfpool max account budget for swap instructions.
+ * Lower values improve compatibility with local validators.
+ */
+exports.LOCAL_TEST_MAX_ACCOUNTS = 20;
+/**
+ * DEXes to exclude in local/Surfpool tests.
+ * Production/testnet deployments should not apply this list by default.
+ */
+exports.LOCAL_TEST_EXCLUDED_DEXES = ["GoonFi", "HumidiFi", "TesseraV", "1DEX", "Aquifer"];
+/**
+ * Venues excluded from ALL Jupiter quotes, in every environment. These
+ * proprietary market-maker venues rotate their vault token accounts
+ * off-chain, so quoted routes intermittently fail at execution with
+ * "Token account ... has wrong owner". Not applied when a `dexes`
+ * whitelist is set (the whitelist takes full control of routing).
+ *
+ * TODO(2026-07-06): Riptide was excluded after repeated wrong-owner failures
+ * on PYUSD routes. It often quotes the best stable-pair price, so revisit
+ * later and give it another chance if their account rotation has stabilized.
+ */
+exports.ALWAYS_EXCLUDED_DEXES = ["Riptide"];

package/dist/shared/jupiter-helpers/src/extract.d.ts

@@ -0,0 +1,30 @@
+import type { Address, Rpc, SolanaRpcApi, Transaction } from "@solana/kit";
+import type { ExtractedJupiterInstruction } from "./types";
+/**
+ * Extract Jupiter instruction data and accounts from a Kit transaction.
+ *
+ * This function decompiles a Jupiter swap transaction, resolves any address lookup tables,
+ * and extracts the instruction data and account metas needed for CPI calls.
+ *
+ * @param transaction - The Kit Transaction from Jupiter API
+ * @param rpc - Solana RPC client to resolve lookup tables
+ * @param jupiterProgramId - Jupiter program ID (default: JUPITER_V6_PROGRAM_ID)
+ * @returns Jupiter instruction data and account metas with writability info
+ * @throws Error if Jupiter instruction is not found in transaction
+ *
+ * @example
+ * ```typescript
+ * // Get transaction from Jupiter API
+ * const jupiterTx = await buildJupiterSwapTransaction({ quote, userPublicKey });
+ *
+ * // Extract instruction for CPI
+ * const { data, accounts } = await extractJupiterInstruction(jupiterTx, rpc);
+ *
+ * // Use in your program
+ * await program.methods
+ *   .executeSwap({ jupiterSwapData: Array.from(data) })
+ *   .remainingAccounts(accounts)
+ *   .rpc();
+ * ```
+ */
+export declare function extractJupiterInstruction(transaction: Transaction, rpc: Rpc<SolanaRpcApi>, jupiterProgramId?: Address): Promise<ExtractedJupiterInstruction>;

package/dist/shared/jupiter-helpers/src/extract.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractJupiterInstruction = extractJupiterInstruction;
+const kit_1 = require("@solana/kit");
+const constants_1 = require("./constants");
+/**
+ * Extract Jupiter instruction data and accounts from a Kit transaction.
+ *
+ * This function decompiles a Jupiter swap transaction, resolves any address lookup tables,
+ * and extracts the instruction data and account metas needed for CPI calls.
+ *
+ * @param transaction - The Kit Transaction from Jupiter API
+ * @param rpc - Solana RPC client to resolve lookup tables
+ * @param jupiterProgramId - Jupiter program ID (default: JUPITER_V6_PROGRAM_ID)
+ * @returns Jupiter instruction data and account metas with writability info
+ * @throws Error if Jupiter instruction is not found in transaction
+ *
+ * @example
+ * ```typescript
+ * // Get transaction from Jupiter API
+ * const jupiterTx = await buildJupiterSwapTransaction({ quote, userPublicKey });
+ *
+ * // Extract instruction for CPI
+ * const { data, accounts } = await extractJupiterInstruction(jupiterTx, rpc);
+ *
+ * // Use in your program
+ * await program.methods
+ *   .executeSwap({ jupiterSwapData: Array.from(data) })
+ *   .remainingAccounts(accounts)
+ *   .rpc();
+ * ```
+ */
+async function extractJupiterInstruction(transaction, rpc, jupiterProgramId = constants_1.JUPITER_V6_PROGRAM_ID) {
+    // Decode the message bytes to a CompiledTransactionMessage
+    const messageDecoder = (0, kit_1.getCompiledTransactionMessageDecoder)();
+    const compiledMessage = messageDecoder.decode(transaction.messageBytes);
+    // Extract lookup table addresses from the compiled message before decompiling
+    const lookupTables = ("addressTableLookups" in compiledMessage ? (compiledMessage.addressTableLookups ?? []) : []).map((lookup) => lookup.lookupTableAddress);
+    // Decompile the transaction message, fetching any lookup tables needed
+    const decompiledMessage = await (0, kit_1.decompileTransactionMessageFetchingLookupTables)(compiledMessage, rpc);
+    // Find the Jupiter instruction
+    const jupiterIx = decompiledMessage.instructions.find((ix) => ix.programAddress === jupiterProgramId);
+    if (!jupiterIx) {
+        throw new Error("Jupiter instruction not found in transaction");
+    }
+    // Convert instruction accounts to AccountMeta format
+    const accounts = (jupiterIx.accounts ?? []).map((account) => ({
+        address: account.address,
+        role: account.role,
+    }));
+    // Return instruction data, accounts, and lookup tables
+    return {
+        data: new Uint8Array(jupiterIx.data ?? []),
+        accounts,
+        lookupTables,
+    };
+}

package/dist/shared/jupiter-helpers/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./constants";
+export * from "./types";
+export * from "./client";
+export * from "./sizeExactInForMinOutput";
+export * from "./routePreInstructions";

package/dist/shared/jupiter-helpers/src/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./sizeExactInForMinOutput"), exports);
+__exportStar(require("./routePreInstructions"), exports);

package/dist/shared/jupiter-helpers/src/routePreInstructions.d.ts

@@ -0,0 +1,19 @@
+import type { Address, Instruction, Rpc, SolanaRpcApi } from "@solana/kit";
+import type { QuoteResponse } from "@jup-ag/api";
+import { type TransactionCacheInvalidation } from "common";
+export interface JupiterRoutePreInstructionsResult {
+    instructions: Instruction[];
+    postSuccessCacheInvalidations: TransactionCacheInvalidation[];
+}
+/**
+ * Build idempotent createATA instructions for every intermediate-mint touched
+ * by a Jupiter route that the swap authority (`user`) doesn't already have an
+ * ATA for. Input/output mints are excluded — the caller is expected to have
+ * already provisioned those (e.g. flash-borrow lands the input balance in
+ * the user's destDebt ATA).
+ *
+ * Token programs are resolved via the {@link mints} registry first; unknown
+ * mints fall back to an RPC `getMultipleAccounts` lookup that reads each
+ * mint's `owner` (the SPL Token vs Token-2022 program).
+ */
+export declare function getJupiterRoutePreInstructions(rpc: Rpc<SolanaRpcApi>, quote: QuoteResponse, user: Address, payer: Address): Promise<JupiterRoutePreInstructionsResult>;

package/dist/shared/jupiter-helpers/src/routePreInstructions.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJupiterRoutePreInstructions = getJupiterRoutePreInstructions;
+const common_1 = require("common");
+/**
+ * Build idempotent createATA instructions for every intermediate-mint touched
+ * by a Jupiter route that the swap authority (`user`) doesn't already have an
+ * ATA for. Input/output mints are excluded — the caller is expected to have
+ * already provisioned those (e.g. flash-borrow lands the input balance in
+ * the user's destDebt ATA).
+ *
+ * Token programs are resolved via the {@link mints} registry first; unknown
+ * mints fall back to an RPC `getMultipleAccounts` lookup that reads each
+ * mint's `owner` (the SPL Token vs Token-2022 program).
+ */
+async function getJupiterRoutePreInstructions(rpc, quote, user, payer) {
+    const intermediate = new Set();
+    for (const step of quote.routePlan ?? []) {
+        intermediate.add(step.swapInfo.inputMint);
+        intermediate.add(step.swapInfo.outputMint);
+    }
+    intermediate.delete(quote.inputMint);
+    intermediate.delete(quote.outputMint);
+    if (!intermediate.size) {
+        return { instructions: [], postSuccessCacheInvalidations: [] };
+    }
+    const tokenProgramByMint = new Map();
+    const unknown = [];
+    for (const mint of intermediate) {
+        const info = common_1.mints.get(mint);
+        if (info) {
+            tokenProgramByMint.set(mint, info.tokenProgram);
+        }
+        else {
+            unknown.push(mint);
+        }
+    }
+    if (unknown.length) {
+        const resp = await rpc
+            .getMultipleAccounts(unknown, { encoding: "base64" })
+            .send();
+        for (let i = 0; i < unknown.length; i += 1) {
+            const acct = resp.value[i];
+            if (!acct) {
+                throw new Error(`getJupiterRoutePreInstructions: route mint ${unknown[i]} not found on-chain`);
+            }
+            tokenProgramByMint.set(unknown[i], acct.owner);
+        }
+    }
+    const instructions = [];
+    const postSuccessCacheInvalidations = [];
+    for (const mint of intermediate) {
+        const tokenProgram = tokenProgramByMint.get(mint);
+        const result = await (0, common_1.getCreateAtaIxIfNeeded)(rpc, payer, mint, user, tokenProgram);
+        if (result.instruction) {
+            instructions.push(result.instruction);
+            postSuccessCacheInvalidations.push(...result.postSuccessCacheInvalidations);
+        }
+    }
+    return { instructions, postSuccessCacheInvalidations };
+}

package/dist/shared/jupiter-helpers/src/sizeExactInForMinOutput.d.ts

@@ -0,0 +1,70 @@
+import type { Address } from "@solana/kit";
+import type { SwapClient, SwapQuote } from "common";
+export declare class ExactInQuoteExceedsMaxInputError extends Error {
+    readonly inputAmount: bigint;
+    readonly maxInputAmount: bigint;
+    constructor(inputAmount: bigint, maxInputAmount: bigint);
+}
+export interface SizeExactInForMinOutputParams {
+    /** Input mint of the swap. */
+    inputMint: Address;
+    /** Output mint of the swap. */
+    outputMint: Address;
+    /** Minimum acceptable output amount (smallest units of `outputMint`). */
+    minOutputAmount: bigint;
+    /**
+     * Maximum input amount the caller is willing to spend (smallest units of
+     * `inputMint`). Throws if the sized input would exceed this.
+     */
+    maxInputAmount: bigint;
+    /** Slippage tolerance applied by the swap, in basis points (e.g. 50 = 0.5%). */
+    slippageBps: number;
+    /**
+     * Extra bps of headroom added on top of slippage when sizing the input.
+     * The worst-case post-slippage output is pushed above `minOutputAmount`
+     * by this much. Defaults to 0 (size to bare minimum).
+     */
+    safetyBufferBps?: number;
+    /**
+     * If true, restrict the quotes to direct routes (no intermediate hops).
+     * Useful for CPI flows where intermediate-mint ATAs (e.g. WSOL) wouldn't
+     * exist for a PDA caller. Defaults to false.
+     */
+    onlyDirectRoutes?: boolean;
+    /** Optional route account budget forwarded to backends that support it. */
+    maxAccounts?: number;
+    /** DEX labels to exclude from routing, forwarded to backends that support it. */
+    excludeDexes?: string[];
+}
+export interface SizeExactInForMinOutputResult<TRawQuote = unknown> {
+    /** ExactIn quote sized so the worst-case output covers `minOutputAmount`. */
+    quote: SwapQuote<TRawQuote>;
+    /** The sized input amount in `inputMint` base units (== `quote.inputAmount`). */
+    inputAmount: bigint;
+    /** The minimum output the caller can rely on after applying slippage. */
+    worstCaseOutputAmount: bigint;
+}
+/**
+ * Size an ExactIn swap so its **worst-case post-slippage output** covers
+ * `minOutputAmount`.
+ *
+ * The ExactIn route graph is denser than ExactOut on most aggregators
+ * (Jupiter included), so this is preferred when ExactOut hits
+ * `NO_ROUTES_FOUND`. The trade-off: you over-spend input by the slippage
+ * buffer; the unused output excess is the caller's to handle (e.g. sweep
+ * to a sink account).
+ *
+ * Strategy:
+ *   1. Probe quote at `minOutputAmount` input — gives us the route's
+ *      spot rate (`probeOut / probeIn`).
+ *   2. Solve for the input `I` such that
+ *      `I × probeOut/probeIn × (1 − slippageBps/10000) ≥ minOutputAmount × (1 + safetyBufferBps/10000)`.
+ *   3. Real ExactIn quote at the sized input.
+ *   4. Verify the real quote's worst-case output still covers
+ *      `minOutputAmount` — guards against price impact at the larger size
+ *      diverging from the probe's spot rate.
+ *
+ * Throws if `inputAmount` exceeds `maxInputAmount`, if `slippageBps` is
+ * out of range, or if the verification in step 4 fails.
+ */
+export declare function sizeExactInForMinOutput<TRawQuote = unknown>(swap: SwapClient<TRawQuote>, params: SizeExactInForMinOutputParams): Promise<SizeExactInForMinOutputResult<TRawQuote>>;

package/dist/shared/jupiter-helpers/src/sizeExactInForMinOutput.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExactInQuoteExceedsMaxInputError = void 0;
+exports.sizeExactInForMinOutput = sizeExactInForMinOutput;
+class ExactInQuoteExceedsMaxInputError extends Error {
+    constructor(inputAmount, maxInputAmount) {
+        super(`sizeExactInForMinOutput: sized input (${inputAmount}) exceeds maxInputAmount (${maxInputAmount})`);
+        this.inputAmount = inputAmount;
+        this.maxInputAmount = maxInputAmount;
+        this.name = "ExactInQuoteExceedsMaxInputError";
+    }
+}
+exports.ExactInQuoteExceedsMaxInputError = ExactInQuoteExceedsMaxInputError;
+/**
+ * Size an ExactIn swap so its **worst-case post-slippage output** covers
+ * `minOutputAmount`.
+ *
+ * The ExactIn route graph is denser than ExactOut on most aggregators
+ * (Jupiter included), so this is preferred when ExactOut hits
+ * `NO_ROUTES_FOUND`. The trade-off: you over-spend input by the slippage
+ * buffer; the unused output excess is the caller's to handle (e.g. sweep
+ * to a sink account).
+ *
+ * Strategy:
+ *   1. Probe quote at `minOutputAmount` input — gives us the route's
+ *      spot rate (`probeOut / probeIn`).
+ *   2. Solve for the input `I` such that
+ *      `I × probeOut/probeIn × (1 − slippageBps/10000) ≥ minOutputAmount × (1 + safetyBufferBps/10000)`.
+ *   3. Real ExactIn quote at the sized input.
+ *   4. Verify the real quote's worst-case output still covers
+ *      `minOutputAmount` — guards against price impact at the larger size
+ *      diverging from the probe's spot rate.
+ *
+ * Throws if `inputAmount` exceeds `maxInputAmount`, if `slippageBps` is
+ * out of range, or if the verification in step 4 fails.
+ */
+async function sizeExactInForMinOutput(swap, params) {
+    const { inputMint, outputMint, minOutputAmount, maxInputAmount, slippageBps, safetyBufferBps = 0, onlyDirectRoutes, maxAccounts, excludeDexes, } = params;
+    if (minOutputAmount <= 0n) {
+        throw new Error("sizeExactInForMinOutput: minOutputAmount must be positive");
+    }
+    if (maxInputAmount <= 0n) {
+        throw new Error("sizeExactInForMinOutput: maxInputAmount must be positive");
+    }
+    if (slippageBps < 0 || slippageBps >= 10000) {
+        throw new Error("sizeExactInForMinOutput: slippageBps must be in [0, 10000)");
+    }
+    if (safetyBufferBps < 0) {
+        throw new Error("sizeExactInForMinOutput: safetyBufferBps must be non-negative");
+    }
+    if (minOutputAmount > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error("sizeExactInForMinOutput: minOutputAmount exceeds Number.MAX_SAFE_INTEGER");
+    }
+    const probeQuote = await swap.getQuote({
+        inputMint,
+        outputMint,
+        amount: Number(minOutputAmount),
+        slippageBps,
+        onlyDirectRoutes,
+        maxAccounts,
+        excludeDexes,
+    });
+    if (probeQuote.outputAmount <= 0n || probeQuote.inputAmount <= 0n) {
+        throw new Error("sizeExactInForMinOutput: probe quote returned non-positive amounts");
+    }
+    // I = ceil(minOutput × probeIn × (10000 + safetyBufferBps) /
+    //          (probeOut × (10000 - slippageBps)))
+    const slippageBpsBig = BigInt(slippageBps);
+    const safetyBpsBig = BigInt(safetyBufferBps);
+    const sizingNumer = minOutputAmount * probeQuote.inputAmount * (10000n + safetyBpsBig);
+    const sizingDenom = probeQuote.outputAmount * (10000n - slippageBpsBig);
+    const inputAmount = (sizingNumer + sizingDenom - 1n) / sizingDenom;
+    if (inputAmount > maxInputAmount) {
+        throw new ExactInQuoteExceedsMaxInputError(inputAmount, maxInputAmount);
+    }
+    if (inputAmount > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw new Error("sizeExactInForMinOutput: sized input exceeds Number.MAX_SAFE_INTEGER");
+    }
+    const quote = await swap.getQuote({
+        inputMint,
+        outputMint,
+        amount: Number(inputAmount),
+        slippageBps,
+        onlyDirectRoutes,
+        maxAccounts,
+        excludeDexes,
+    });
+    const worstCaseOutputAmount = (quote.outputAmount * (10000n - slippageBpsBig)) / 10000n;
+    if (worstCaseOutputAmount < minOutputAmount) {
+        throw new Error(`sizeExactInForMinOutput: real-quote worst-case output (${worstCaseOutputAmount}) ` +
+            `does not cover minOutputAmount (${minOutputAmount}) — likely price impact at sized input ` +
+            `diverged from probe spot rate; raise safetyBufferBps`);
+    }
+    return { quote, inputAmount, worstCaseOutputAmount };
+}