@kestrelfi/lyc-sdk 1.0.1 → 1.0.3

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

@@ -1,127 +0,0 @@
-"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

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

@@ -1,122 +0,0 @@
-"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

@@ -1,59 +0,0 @@
-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

@@ -1,130 +0,0 @@
-"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

@@ -1,79 +0,0 @@
-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>;
-}