@kestrelfi/lyc-sdk 1.0.1

package/dist/shared/common/src/utils/transactionSplitter.js

@@ -0,0 +1,127 @@
+"use strict";
+/**
+ * Greedy bin-packing splitter for instruction lists that exceed the Solana
+ * transaction wire limit (1232 bytes).
+ *
+ * Instructions are packed left-to-right (preserving caller order) into the
+ * fewest bins where each bin compiles to a valid-sized transaction. The
+ * result is an ordered array of instruction arrays, each of which can be
+ * independently built into a v0 `TransactionMessage`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOLANA_TX_SIZE_LIMIT = void 0;
+exports.measureTxBytes = measureTxBytes;
+exports.buildInstructionSegments = buildInstructionSegments;
+exports.splitIntoTransactionBins = splitIntoTransactionBins;
+const kit_1 = require("@solana/kit");
+const transaction_1 = require("./transaction");
+const jito_1 = require("./jito");
+/**
+ * Solana's maximum serialized transaction size in bytes. The base64 encoding
+ * inflates this to ~1644 chars, but we measure the decoded wire bytes via
+ * Kit's `compileTransaction` + `getBase64EncodedWireTransaction` and compare
+ * against the decoded length.
+ */
+exports.SOLANA_TX_SIZE_LIMIT = 1232;
+/**
+ * Measure the wire size of a compilable transaction message in bytes.
+ */
+function measureTxBytes(msg) {
+    const compiled = (0, kit_1.compileTransaction)(msg);
+    const b64 = (0, kit_1.getBase64EncodedWireTransaction)(compiled);
+    return Math.ceil((b64.length * 3) / 4);
+}
+/**
+ * Turn a flat instruction list into indivisible segments for bin-packing.
+ *
+ * @throws If lengths are invalid or do not partition `instructions`.
+ */
+function buildInstructionSegments(instructions, segmentLengths) {
+    if (segmentLengths === undefined || segmentLengths.length === 0) {
+        return instructions.map((ix) => [ix]);
+    }
+    const sum = segmentLengths.reduce((a, b) => a + b, 0);
+    if (sum !== instructions.length) {
+        throw new Error(`segmentLengths sum (${sum}) must equal instructions.length (${instructions.length}).`);
+    }
+    if (segmentLengths.some((n) => !Number.isInteger(n) || n <= 0)) {
+        throw new Error("segmentLengths entries must be positive integers.");
+    }
+    const segments = [];
+    let offset = 0;
+    for (const len of segmentLengths) {
+        segments.push(instructions.slice(offset, offset + len));
+        offset += len;
+    }
+    return segments;
+}
+/**
+ * Split an instruction list into the minimum number of ordered bins where
+ * each bin compiles to a transaction within the wire-size limit (minus
+ * `reservedBytes` of headroom for post-split instruction injection).
+ *
+ * Preserves instruction ordering: segments and instructions are never
+ * reordered across bins. Each bin is measured by actually compiling a v0
+ * message with the provided fee payer + ALTs, so the measurement accounts for
+ * signatures, account tables, and compact-u16 encoding exactly.
+ *
+ * Throws if:
+ * - A single segment cannot fit in one tx (even alone).
+ * - The total bins exceed `MAX_BUNDLE_TRANSACTIONS` (Jito's 5-tx limit).
+ */
+async function splitIntoTransactionBins(rpc, payer, instructions, options = {}) {
+    const { lookupTables, additionalSigners, blockhash, reservedBytes = 0, segmentLengths, freshBinSegments, } = options;
+    const effectiveLimit = exports.SOLANA_TX_SIZE_LIMIT - reservedBytes;
+    const freshBinSet = freshBinSegments ? new Set(freshBinSegments) : undefined;
+    if (effectiveLimit <= 0) {
+        throw new Error(`reservedBytes (${reservedBytes}) is >= the tx size limit (${exports.SOLANA_TX_SIZE_LIMIT}).`);
+    }
+    const segments = buildInstructionSegments(instructions, segmentLengths);
+    const bins = [];
+    let currentBin = [];
+    const measureCandidate = async (candidate) => {
+        const msg = await (0, transaction_1.buildTransactionMessage)(rpc, payer, candidate, lookupTables, additionalSigners, blockhash);
+        return measureTxBytes(msg);
+    };
+    for (let segIdx = 0; segIdx < segments.length; segIdx += 1) {
+        const segment = segments[segIdx];
+        // If this segment must start a fresh bin, flush the current bin first
+        // so the segment lands at the start of a new bin.
+        if (freshBinSet?.has(segIdx) && currentBin.length > 0) {
+            bins.push(currentBin);
+            currentBin = [];
+        }
+        const candidate = [...currentBin, ...segment];
+        const size = await measureCandidate(candidate);
+        if (size <= effectiveLimit) {
+            currentBin = candidate;
+            continue;
+        }
+        // Segment doesn't fit in the current bin. If the bin is non-empty, flush
+        // it and start a new bin with the whole segment. If the bin IS empty,
+        // the segment is too large on its own — unrecoverable.
+        if (currentBin.length === 0) {
+            throw new Error(`An indivisible instruction group (${segment.length} instruction(s)) measures ` +
+                `${size} bytes, exceeding the ${effectiveLimit}-byte effective tx size limit ` +
+                `(${exports.SOLANA_TX_SIZE_LIMIT} - ${reservedBytes} reserved) even with address lookup ` +
+                `tables. Cannot split.`);
+        }
+        bins.push(currentBin);
+        currentBin = [...segment];
+        const segmentSize = await measureCandidate(currentBin);
+        if (segmentSize > effectiveLimit) {
+            throw new Error(`An indivisible instruction group (${segment.length} instruction(s)) measures ` +
+                `${segmentSize} bytes, exceeding the ${effectiveLimit}-byte effective tx size limit ` +
+                `(${exports.SOLANA_TX_SIZE_LIMIT} - ${reservedBytes} reserved) even with address lookup ` +
+                `tables. Cannot split.`);
+        }
+    }
+    if (currentBin.length > 0) {
+        bins.push(currentBin);
+    }
+    if (bins.length > jito_1.MAX_BUNDLE_TRANSACTIONS) {
+        throw new Error(`Instruction list requires ${bins.length} transactions, but Jito bundles ` +
+            `allow at most ${jito_1.MAX_BUNDLE_TRANSACTIONS}.`);
+    }
+    return { bins };
+}

package/dist/shared/common/src/utils/txAccountCoverage.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Diagnostic helpers for inspecting which addresses a transaction references
+ * and whether they are covered by the caller's address lookup tables.
+ *
+ * Useful when bin-packing fails: if a segment is over the per-tx wire limit,
+ * the cheapest fix is usually adding addresses to a LUT so the compiler can
+ * compress them from 32-byte static keys down to 1-byte indices. This module
+ * surfaces the candidates by cross-referencing every account touched by the
+ * instruction list against the full contents of every passed LUT.
+ */
+import type { Address, Instruction, Rpc, SolanaRpcApi, TransactionSigner } from "@solana/kit";
+export interface LutUsage {
+    /** Addresses pulled from this LUT into the compiled message's writable section. */
+    writable: Address[];
+    /** Addresses pulled from this LUT into the compiled message's readonly section. */
+    readonly: Address[];
+    /** Total addresses stored in the LUT (capacity reference). */
+    size: number;
+}
+export interface AccountCoverageReport {
+    /** Compiled message's static account list (programs, fee payer, anything not LUT'd). */
+    staticAccounts: Address[];
+    /** Per-LUT: which entries the compiler actually used, plus the LUT's full size. */
+    lutUsage: Map<Address, LutUsage>;
+    /** All distinct addresses referenced by the instructions (programs + accounts + fee payer). */
+    referenced: Address[];
+    /** Distinct program IDs across all instructions (forced into static keys). */
+    programIds: Address[];
+    /** Addresses referenced but NOT present in any caller-supplied LUT. */
+    uncoveredByCallerLuts: Address[];
+    /**
+     * Subset of `uncoveredByCallerLuts` that excludes program IDs and the fee
+     * payer — i.e., concrete candidates to add to a LUT for further compression.
+     */
+    candidatesToAddToLut: Address[];
+}
+/**
+ * Compile the message with the caller's LUTs, decode the result, and produce
+ * a report describing which addresses are static, which came from LUTs, and
+ * which referenced addresses are still uncovered.
+ *
+ * Note: program IDs MUST live in the static account list — the v0 message
+ * format does not allow LUT lookup for the program-id slot. The report keeps
+ * them in `referenced` and `programIds` but excludes them from
+ * `candidatesToAddToLut` since putting a program in a LUT cannot help.
+ */
+export declare function reportAccountCoverage(rpc: Rpc<SolanaRpcApi>, payer: TransactionSigner, instructions: Instruction[], lookupTableAddresses: Address[] | undefined): Promise<AccountCoverageReport>;
+/** Pretty-print a coverage report. Designed for CLI/script diagnostic use. */
+export declare function logAccountCoverage(label: string, report: AccountCoverageReport): void;

package/dist/shared/common/src/utils/txAccountCoverage.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * Diagnostic helpers for inspecting which addresses a transaction references
+ * and whether they are covered by the caller's address lookup tables.
+ *
+ * Useful when bin-packing fails: if a segment is over the per-tx wire limit,
+ * the cheapest fix is usually adding addresses to a LUT so the compiler can
+ * compress them from 32-byte static keys down to 1-byte indices. This module
+ * surfaces the candidates by cross-referencing every account touched by the
+ * instruction list against the full contents of every passed LUT.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportAccountCoverage = reportAccountCoverage;
+exports.logAccountCoverage = logAccountCoverage;
+const kit_1 = require("@solana/kit");
+const lutManager_1 = require("../services/lutManager");
+const transaction_1 = require("./transaction");
+/**
+ * Compile the message with the caller's LUTs, decode the result, and produce
+ * a report describing which addresses are static, which came from LUTs, and
+ * which referenced addresses are still uncovered.
+ *
+ * Note: program IDs MUST live in the static account list — the v0 message
+ * format does not allow LUT lookup for the program-id slot. The report keeps
+ * them in `referenced` and `programIds` but excludes them from
+ * `candidatesToAddToLut` since putting a program in a LUT cannot help.
+ */
+async function reportAccountCoverage(rpc, payer, instructions, lookupTableAddresses) {
+    // Fetch the FULL contents of every caller-supplied LUT (regardless of which
+    // entries the compiler ends up referencing) so we can answer "is this
+    // address in any of MY LUTs?" — the actionable question for tightening
+    // coverage.
+    const callerLuts = lookupTableAddresses?.length
+        ? await lutManager_1.lutManager.getLookupTableInputs(rpc, lookupTableAddresses)
+        : [];
+    const callerLutAddressSet = new Set(callerLuts.flatMap((l) => l.addresses));
+    // Compile the message with LUTs to see what actually got compressed and
+    // what spilled into the static account list.
+    const msg = await (0, transaction_1.buildTransactionMessage)(rpc, payer, instructions, lookupTableAddresses);
+    const compiled = (0, kit_1.compileTransaction)(msg);
+    const decoded = (0, kit_1.getCompiledTransactionMessageDecoder)().decode(compiled.messageBytes);
+    const staticAccounts = (decoded.staticAccounts ?? []);
+    const altLookups = "addressTableLookups" in decoded ? (decoded.addressTableLookups ?? []) : [];
+    const lutUsage = new Map();
+    for (const lut of callerLuts) {
+        lutUsage.set(lut.address, { writable: [], readonly: [], size: lut.addresses.length });
+    }
+    for (const lookup of altLookups) {
+        const fullAddrs = callerLuts.find((l) => l.address === lookup.lookupTableAddress)?.addresses;
+        const usage = lutUsage.get(lookup.lookupTableAddress) ?? {
+            writable: [],
+            readonly: [],
+            size: fullAddrs?.length ?? 0,
+        };
+        if (fullAddrs) {
+            usage.writable = lookup.writableIndexes.map((i) => fullAddrs[i]);
+            usage.readonly = lookup.readonlyIndexes.map((i) => fullAddrs[i]);
+        }
+        lutUsage.set(lookup.lookupTableAddress, usage);
+    }
+    const referencedSet = new Set();
+    const programSet = new Set();
+    referencedSet.add(payer.address);
+    for (const ix of instructions) {
+        referencedSet.add(ix.programAddress);
+        programSet.add(ix.programAddress);
+        for (const acc of ix.accounts ?? []) {
+            referencedSet.add(acc.address);
+        }
+    }
+    const referenced = [...referencedSet];
+    const programIds = [...programSet];
+    const uncoveredByCallerLuts = referenced.filter((a) => !callerLutAddressSet.has(a));
+    const candidatesToAddToLut = uncoveredByCallerLuts.filter((a) => a !== payer.address && !programSet.has(a));
+    return {
+        staticAccounts,
+        lutUsage,
+        referenced,
+        programIds,
+        uncoveredByCallerLuts,
+        candidatesToAddToLut,
+    };
+}
+/** Pretty-print a coverage report. Designed for CLI/script diagnostic use. */
+function logAccountCoverage(label, report) {
+    console.log(`\n── Account coverage: ${label} ──`);
+    console.log(`Compiled static accounts (${report.staticAccounts.length}) — programs, fee payer, and uncompressed:`);
+    report.staticAccounts.forEach((a, i) => console.log(`  [${i}] ${a}`));
+    console.log(`\nCaller-supplied LUTs (${report.lutUsage.size}):`);
+    if (report.lutUsage.size === 0) {
+        console.log("  (none)");
+    }
+    for (const [lut, usage] of report.lutUsage) {
+        const used = usage.writable.length + usage.readonly.length;
+        console.log(`  ${lut}  size=${usage.size} used=${used}`);
+        if (usage.writable.length > 0) {
+            console.log(`    writable (${usage.writable.length}): ${usage.writable.join(", ")}`);
+        }
+        if (usage.readonly.length > 0) {
+            console.log(`    readonly (${usage.readonly.length}): ${usage.readonly.join(", ")}`);
+        }
+    }
+    console.log(`\nReferenced addresses: ${report.referenced.length} ` +
+        `(${report.programIds.length} program ID${report.programIds.length === 1 ? "" : "s"})`);
+    console.log(`\nReferenced but NOT in any caller LUT (${report.uncoveredByCallerLuts.length}):`);
+    if (report.uncoveredByCallerLuts.length === 0) {
+        console.log("  (none — every referenced address is in at least one caller LUT)");
+    }
+    else {
+        for (const a of report.uncoveredByCallerLuts) {
+            const tag = report.programIds.includes(a) ? "  [PROGRAM — must be static]" : "";
+            console.log(`  ${a}${tag}`);
+        }
+    }
+    console.log(`\nCandidates to add to a LUT (excludes programs + fee payer; ${report.candidatesToAddToLut.length}):`);
+    if (report.candidatesToAddToLut.length === 0) {
+        console.log("  (none — uncovered addresses are all programs or the fee payer)");
+    }
+    else {
+        report.candidatesToAddToLut.forEach((a) => console.log(`  ${a}`));
+    }
+}

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

@@ -0,0 +1,59 @@
+import type { Address, Transaction } from "@solana/kit";
+import type { QuoteResponse } from "@jup-ag/api";
+import type { JupiterQuoteParams, JupiterSwapParams } from "./types";
+/**
+ * Get a Jupiter swap quote.
+ *
+ * @param params - Quote parameters
+ * @returns Quote response from Jupiter API
+ *
+ * @example
+ * ```typescript
+ * const quote = await getJupiterQuote({
+ *   inputMint: address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
+ *   outputMint: address("So11111111111111111111111111111111111111112"),
+ *   amount: 1000_000, // 1 USDC (6 decimals)
+ * });
+ * ```
+ */
+export declare function getJupiterQuote(params: JupiterQuoteParams): Promise<QuoteResponse>;
+/**
+ * Build a Jupiter swap transaction from a quote.
+ *
+ * @param params - Swap parameters including quote and user public key
+ * @returns Kit Transaction ready for signing or instruction extraction
+ *
+ * @example
+ * ```typescript
+ * const quote = await getJupiterQuote({ ... });
+ * const tx = await buildJupiterSwapTransaction({
+ *   quote,
+ *   userPublicKey: myPdaAddress, // Can be a PDA for CPI
+ * });
+ * ```
+ */
+export declare function buildJupiterSwapTransaction(params: JupiterSwapParams): Promise<Transaction>;
+/**
+ * Convenience function to get quote and build transaction in one call.
+ *
+ * @param quoteParams - Quote parameters
+ * @param userPublicKey - Address that will execute the swap
+ * @param swapOptions - Additional swap options
+ * @returns Quote response and Kit transaction
+ *
+ * @example
+ * ```typescript
+ * const { quote, transaction } = await getJupiterSwapTransaction(
+ *   {
+ *     inputMint: address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
+ *     outputMint: address("So11111111111111111111111111111111111111112"),
+ *     amount: 1000_000,
+ *   },
+ *   myPdaAddress
+ * );
+ * ```
+ */
+export declare function getJupiterSwapTransaction(quoteParams: JupiterQuoteParams, userPublicKey: Address, swapOptions?: Omit<JupiterSwapParams, "quote" | "userPublicKey">): Promise<{
+    quote: QuoteResponse;
+    transaction: Transaction;
+}>;

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

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJupiterQuote = getJupiterQuote;
+exports.buildJupiterSwapTransaction = buildJupiterSwapTransaction;
+exports.getJupiterSwapTransaction = getJupiterSwapTransaction;
+const kit_1 = require("@solana/kit");
+const api_1 = require("@jup-ag/api");
+const constants_1 = require("./constants");
+/**
+ * Get a Jupiter swap quote.
+ *
+ * @param params - Quote parameters
+ * @returns Quote response from Jupiter API
+ *
+ * @example
+ * ```typescript
+ * const quote = await getJupiterQuote({
+ *   inputMint: address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
+ *   outputMint: address("So11111111111111111111111111111111111111112"),
+ *   amount: 1000_000, // 1 USDC (6 decimals)
+ * });
+ * ```
+ */
+async function getJupiterQuote(params) {
+    const jupiterApi = (0, api_1.createJupiterApiClient)({ basePath: constants_1.JUPITER_API_URL });
+    const amount = typeof params.amount === "bigint" ? Number(params.amount) : params.amount;
+    const request = {
+        inputMint: params.inputMint,
+        outputMint: params.outputMint,
+        amount,
+        slippageBps: params.slippageBps ?? constants_1.DEFAULT_SLIPPAGE_BPS,
+        swapMode: params.swapMode,
+        maxAccounts: params.maxAccounts,
+        dexes: params.dexes,
+        // When `dexes` is set it acts as a whitelist and `excludeDexes` is irrelevant.
+        // Otherwise the caller's exclusions are merged with the global list.
+        excludeDexes: params.dexes
+            ? undefined
+            : [...new Set([...constants_1.ALWAYS_EXCLUDED_DEXES, ...(params.excludeDexes ?? [])])],
+        onlyDirectRoutes: params.onlyDirectRoutes,
+    };
+    try {
+        return await jupiterApi.quoteGet(request);
+    }
+    catch (err) {
+        throw await enrichJupiterHttpError(err, request);
+    }
+}
+/**
+ * The OpenAPI client throws `ResponseError` with a generic message; the real reason
+ * is usually in the HTTP body (e.g. no route, validation).
+ */
+async function enrichJupiterHttpError(err, request) {
+    if (!(err instanceof Error) || !("response" in err)) {
+        return err instanceof Error ? err : new Error(String(err));
+    }
+    const res = err.response;
+    if (!res || res.ok || typeof res.text !== "function") {
+        return err;
+    }
+    let body = "";
+    try {
+        body = (await res.text()).slice(0, 2000);
+    }
+    catch {
+        body = "<failed to read response body>";
+    }
+    return new Error(`Jupiter quoteGet http=${res.status} ${res.statusText} request=${JSON.stringify(request)} body=${body} (was: ${err.message})`);
+}
+/**
+ * Build a Jupiter swap transaction from a quote.
+ *
+ * @param params - Swap parameters including quote and user public key
+ * @returns Kit Transaction ready for signing or instruction extraction
+ *
+ * @example
+ * ```typescript
+ * const quote = await getJupiterQuote({ ... });
+ * const tx = await buildJupiterSwapTransaction({
+ *   quote,
+ *   userPublicKey: myPdaAddress, // Can be a PDA for CPI
+ * });
+ * ```
+ */
+async function buildJupiterSwapTransaction(params) {
+    const jupiterApi = (0, api_1.createJupiterApiClient)({ basePath: constants_1.JUPITER_API_URL });
+    const swapResult = await jupiterApi.swapPost({
+        swapRequest: {
+            quoteResponse: params.quote,
+            userPublicKey: params.userPublicKey,
+            wrapAndUnwrapSol: params.wrapAndUnwrapSol ?? false, // Default false for CPI
+            dynamicComputeUnitLimit: params.dynamicComputeUnitLimit ?? true,
+        },
+    });
+    // Jupiter returns a base64-encoded serialized transaction
+    // In Kit, "encoder" converts string -> bytes, "decoder" converts bytes -> string
+    const base64Encoder = (0, kit_1.getBase64Encoder)();
+    const transactionBytes = base64Encoder.encode(swapResult.swapTransaction);
+    const transactionDecoder = (0, kit_1.getTransactionDecoder)();
+    return transactionDecoder.decode(transactionBytes);
+}
+/**
+ * Convenience function to get quote and build transaction in one call.
+ *
+ * @param quoteParams - Quote parameters
+ * @param userPublicKey - Address that will execute the swap
+ * @param swapOptions - Additional swap options
+ * @returns Quote response and Kit transaction
+ *
+ * @example
+ * ```typescript
+ * const { quote, transaction } = await getJupiterSwapTransaction(
+ *   {
+ *     inputMint: address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
+ *     outputMint: address("So11111111111111111111111111111111111111112"),
+ *     amount: 1000_000,
+ *   },
+ *   myPdaAddress
+ * );
+ * ```
+ */
+async function getJupiterSwapTransaction(quoteParams, userPublicKey, swapOptions) {
+    const quote = await getJupiterQuote(quoteParams);
+    const transaction = await buildJupiterSwapTransaction({
+        quote,
+        userPublicKey,
+        ...swapOptions,
+    });
+    return { quote, transaction };
+}

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

@@ -0,0 +1,79 @@
+import { type Address, type Rpc, type SolanaRpcApi } from "@solana/kit";
+import type { QuoteResponse } from "@jup-ag/api";
+import type { JupiterSwapClientConfig } from "./types";
+import { CpiData, RoutableSwapClient, SwapQuoteParams, SwapQuote, SwapQuoteCoveringMinOutputParams, SwapInstructionOptions } from "common";
+/** Jupiter-specific swap quote with typed rawQuote */
+export type JupiterSwapQuote = SwapQuote<QuoteResponse>;
+/**
+ * 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();
+ * ```
+ */
+export declare class JupiterSwapClient implements RoutableSwapClient<QuoteResponse> {
+    private rpc;
+    private readonly config;
+    /**
+     * Empty lists mean any route for aggregate routing (Jupiter quotes arbitrary
+     * pairs via the API).
+     */
+    readonly inputMints: readonly Address[];
+    readonly outputMints: readonly Address[];
+    readonly routeAnchorMints: readonly Address[];
+    /**
+     * 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: Rpc<SolanaRpcApi>, config?: JupiterSwapClientConfig);
+    /**
+     * Get a swap quote from Jupiter.
+     *
+     * @param params - Quote parameters
+     * @returns Normalized swap quote with Jupiter's QuoteResponse as rawQuote
+     */
+    getQuote(params: SwapQuoteParams): Promise<JupiterSwapQuote>;
+    /**
+     * Use Jupiter `ExactOut` quoting: desired output is `minOutputAmount`; reject if implied
+     * input exceeds `maxInputAmount`.
+     */
+    getQuoteCoveringMinOutput(params: SwapQuoteCoveringMinOutputParams): Promise<JupiterSwapQuote>;
+    /**
+     * 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
+     */
+    getSwapCpiData(quote: JupiterSwapQuote, userPublicKey: Address, options?: SwapInstructionOptions): Promise<CpiData>;
+}