sol-trade-sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2659 @@
+import { TransactionInstruction, PublicKey, Keypair, Connection, Transaction, Commitment, Finality, AccountInfo, SimulateTransactionConfig, AddressLookupTableAccount as AddressLookupTableAccount$1, BlockhashWithExpiryBlockHeight } from '@solana/web3.js';
+export { i as perf } from './index-1BK_FXsW.js';
+
+/**
+ * Gas Fee Strategy for Sol Trade SDK
+ */
+declare enum TradeType$1 {
+    Buy = "Buy",
+    Sell = "Sell"
+}
+declare enum SwqosType$1 {
+    Default = "Default",
+    Jito = "Jito",
+    Bloxroute = "Bloxroute",
+    ZeroSlot = "ZeroSlot",
+    Temporal = "Temporal",
+    FlashBlock = "FlashBlock",
+    BlockRazor = "BlockRazor",
+    Node1 = "Node1",
+    Astralane = "Astralane",
+    NextBlock = "NextBlock",
+    Helius = "Helius",
+    Stellium = "Stellium",
+    Lightspeed = "Lightspeed",
+    Soyas = "Soyas",
+    Speedlanding = "Speedlanding",
+    Triton = "Triton",
+    QuickNode = "QuickNode",
+    Syndica = "Syndica",
+    Figment = "Figment",
+    Alchemy = "Alchemy"
+}
+declare enum GasFeeStrategyType {
+    Normal = "Normal",
+    LowTipHighCuPrice = "LowTipHighCuPrice",
+    HighTipLowCuPrice = "HighTipLowCuPrice"
+}
+interface GasFeeStrategyValue {
+    cuLimit: number;
+    cuPrice: number;
+    tip: number;
+}
+declare class GasFeeStrategy {
+    private strategies;
+    constructor();
+    /**
+     * Set global fee strategy for all SWQOS types
+     */
+    setGlobalFeeStrategy(buyCuLimit: number, sellCuLimit: number, buyCuPrice: number, sellCuPrice: number, buyTip: number, sellTip: number): void;
+    /**
+     * Set high-low fee strategies for multiple SWQOS types
+     */
+    setHighLowFeeStrategies(swqosTypes: SwqosType$1[], tradeType: TradeType$1, cuLimit: number, lowCuPrice: number, highCuPrice: number, lowTip: number, highTip: number): void;
+    /**
+     * Set a specific gas fee strategy
+     */
+    set(swqosType: SwqosType$1, tradeType: TradeType$1, strategyType: GasFeeStrategyType, cuLimit: number, cuPrice: number, tip: number): void;
+    /**
+     * Get a specific gas fee strategy
+     */
+    get(swqosType: SwqosType$1, tradeType: TradeType$1, strategyType: GasFeeStrategyType): GasFeeStrategyValue | undefined;
+    /**
+     * Delete a specific gas fee strategy
+     */
+    delete(swqosType: SwqosType$1, tradeType: TradeType$1, strategyType: GasFeeStrategyType): void;
+    /**
+     * Delete all strategies for a SWQOS type and trade type
+     */
+    deleteAll(swqosType: SwqosType$1, tradeType: TradeType$1): void;
+    /**
+     * Get all strategies for a trade type
+     */
+    getStrategies(tradeType: TradeType$1): Array<{
+        swqosType: SwqosType$1;
+        strategyType: GasFeeStrategyType;
+        value: GasFeeStrategyValue;
+    }>;
+    /**
+     * Update buy tip for all strategies
+     */
+    updateBuyTip(buyTip: number): void;
+    /**
+     * Update sell tip for all strategies
+     */
+    updateSellTip(sellTip: number): void;
+    /**
+     * Clear all strategies
+     */
+    clear(): void;
+    private getKey;
+    private parseKey;
+}
+
+/**
+ * Shared SDK errors (avoids circular imports with `index` / `swqos`).
+ */
+declare class TradeError extends Error {
+    code: number;
+    cause?: Error | undefined;
+    constructor(code: number, message: string, cause?: Error | undefined);
+}
+
+/**
+ * Middleware trait definitions.
+ * Based on sol-trade-sdk Rust implementation.
+ */
+
+/**
+ * Instruction middleware interface
+ * Used to modify, add or remove instructions before transaction execution
+ */
+interface InstructionMiddleware {
+    /** Middleware name */
+    name(): string;
+    /**
+     * Process protocol instructions
+     * @param protocolInstructions - Current instruction list
+     * @param protocolName - Protocol name
+     * @param isBuy - Whether the transaction is a buy transaction
+     * @returns Modified instruction list
+     */
+    processProtocolInstructions(protocolInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    /**
+     * Process full instructions
+     * @param fullInstructions - Current instruction list
+     * @param protocolName - Protocol name
+     * @param isBuy - Whether the transaction is a buy transaction
+     * @returns Modified instruction list
+     */
+    processFullInstructions(fullInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    /** Clone middleware */
+    clone(): InstructionMiddleware;
+}
+/**
+ * Middleware manager
+ */
+declare class MiddlewareManager {
+    private middlewares;
+    /**
+     * Create new middleware manager
+     */
+    constructor();
+    /**
+     * Add middleware
+     */
+    addMiddleware(middleware: InstructionMiddleware): this;
+    /**
+     * Apply all middlewares to process protocol instructions
+     */
+    applyMiddlewaresProcessProtocolInstructions(protocolInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    /**
+     * Apply all middlewares to process full instructions
+     */
+    applyMiddlewaresProcessFullInstructions(fullInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    /**
+     * Clone the manager
+     */
+    clone(): MiddlewareManager;
+    /**
+     * Create manager with common middlewares
+     */
+    static withCommonMiddlewares(): MiddlewareManager;
+}
+/**
+ * Logging middleware - Records instruction information
+ */
+declare class LoggingMiddleware implements InstructionMiddleware {
+    name(): string;
+    processProtocolInstructions(protocolInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    processFullInstructions(fullInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    clone(): InstructionMiddleware;
+}
+/**
+ * Timer middleware - Measures execution time
+ */
+declare class TimerMiddleware implements InstructionMiddleware {
+    private enabled;
+    name(): string;
+    setEnabled(enabled: boolean): void;
+    processProtocolInstructions(protocolInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    processFullInstructions(fullInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    clone(): InstructionMiddleware;
+}
+/**
+ * Validation middleware - Validates instructions before processing
+ */
+declare class ValidationMiddleware implements InstructionMiddleware {
+    private maxInstructions;
+    private maxDataSize;
+    constructor(maxInstructions?: number, maxDataSize?: number);
+    name(): string;
+    private validate;
+    processProtocolInstructions(protocolInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    processFullInstructions(fullInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    clone(): InstructionMiddleware;
+}
+/**
+ * Filter middleware - Filters instructions based on program ID
+ */
+declare class FilterMiddleware implements InstructionMiddleware {
+    private mode;
+    private allowedPrograms;
+    constructor(programs: PublicKey[], mode?: 'allow' | 'block');
+    name(): string;
+    private filter;
+    processProtocolInstructions(protocolInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    processFullInstructions(fullInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    clone(): InstructionMiddleware;
+}
+/**
+ * Metrics middleware - Collects metrics about instruction processing
+ */
+declare class MetricsMiddleware implements InstructionMiddleware {
+    private instructionCounts;
+    private totalInstructions;
+    private totalDataSize;
+    name(): string;
+    private record;
+    processProtocolInstructions(protocolInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    processFullInstructions(fullInstructions: TransactionInstruction[], protocolName: string, isBuy: boolean): TransactionInstruction[];
+    clone(): InstructionMiddleware;
+    /**
+     * Get collected metrics
+     */
+    getMetrics(): {
+        instructionCounts: Record<string, number>;
+        totalInstructions: number;
+        totalDataSize: number;
+    };
+    /**
+     * Reset metrics
+     */
+    reset(): void;
+}
+/**
+ * Create manager with standard middlewares
+ */
+declare function withStandardMiddlewares(): MiddlewareManager;
+/**
+ * Create manager with all builtin middlewares
+ */
+declare function withAllBuiltinMiddlewares(): MiddlewareManager;
+
+/**
+ * Constants for Sol Trade SDK
+ */
+
+declare const SYSTEM_PROGRAM: PublicKey;
+declare const TOKEN_PROGRAM: PublicKey;
+declare const TOKEN_PROGRAM_2022: PublicKey;
+declare const SOL_TOKEN_ACCOUNT: PublicKey;
+declare const WSOL_TOKEN_ACCOUNT: PublicKey;
+declare const USD1_TOKEN_ACCOUNT: PublicKey;
+declare const USDC_TOKEN_ACCOUNT: PublicKey;
+declare const ASSOCIATED_TOKEN_PROGRAM: PublicKey;
+declare const RENT: PublicKey;
+declare const PUMPFUN_PROGRAM: PublicKey;
+/** PumpSwap AMM program (same as `instruction/pumpswap` PUMPSWAP_PROGRAM) */
+declare const PUMPSWAP_PROGRAM_ID: PublicKey;
+declare const BONK_PROGRAM: PublicKey;
+declare const RAYDIUM_CPMM_PROGRAM: PublicKey;
+declare const RAYDIUM_AMM_V4_PROGRAM: PublicKey;
+declare const METEORA_DAMM_V2_PROGRAM: PublicKey;
+declare const SDK_FEE_RECIPIENT: PublicKey;
+declare const SDK_MAYHEM_FEE_RECIPIENTS: PublicKey[];
+declare const PUMPFUN_DISCRIMINATORS: {
+    BUY: Buffer<ArrayBuffer>;
+    SELL: Buffer<ArrayBuffer>;
+    BUY_EXACT_SOL_IN: Buffer<ArrayBuffer>;
+    CLAIM_CASHBACK: Buffer<ArrayBuffer>;
+};
+declare const PUMPSWAP_DISCRIMINATORS: {
+    SWAP: Buffer<ArrayBuffer>;
+    DEPOSIT: Buffer<ArrayBuffer>;
+    WITHDRAW: Buffer<ArrayBuffer>;
+};
+declare const DEFAULT_SLIPPAGE = 500;
+declare const DEFAULT_COMPUTE_UNITS = 200000;
+declare const DEFAULT_PRIORITY_FEE = 100000;
+declare const DEFAULT_TIP_LAMPORTS = 100000;
+/** Aggregate for consumers expecting a single `CONSTANTS` object (matches historical `index` export). */
+declare const CONSTANTS: {
+    readonly SYSTEM_PROGRAM: PublicKey;
+    readonly TOKEN_PROGRAM: PublicKey;
+    readonly TOKEN_PROGRAM_2022: PublicKey;
+    readonly SOL_TOKEN_ACCOUNT: PublicKey;
+    readonly WSOL_TOKEN_ACCOUNT: PublicKey;
+    readonly USD1_TOKEN_ACCOUNT: PublicKey;
+    readonly USDC_TOKEN_ACCOUNT: PublicKey;
+    readonly ASSOCIATED_TOKEN_PROGRAM: PublicKey;
+    readonly RENT: PublicKey;
+    readonly PUMPFUN_PROGRAM: PublicKey;
+    readonly PUMPSWAP_PROGRAM: PublicKey;
+    readonly BONK_PROGRAM: PublicKey;
+    readonly RAYDIUM_CPMM_PROGRAM: PublicKey;
+    readonly RAYDIUM_AMM_V4_PROGRAM: PublicKey;
+    readonly METEORA_DAMM_V2_PROGRAM: PublicKey;
+    readonly DEFAULT_SLIPPAGE: 500;
+    readonly DEFAULT_COMPUTE_UNITS: 200000;
+    readonly DEFAULT_PRIORITY_FEE: 100000;
+    readonly DEFAULT_TIP_LAMPORTS: 100000;
+};
+declare const SWQOS_ENDPOINTS: Record<string, Record<string, string>>;
+
+/**
+ * PumpFun Protocol Instruction Builder
+ *
+ * Production-grade instruction builder for PumpFun bonding curve protocol.
+ * Supports buy, sell, and cashback claim operations.
+ * 100% port from Rust: src/instruction/pumpfun.rs
+ */
+
+/** PumpFun program ID */
+declare const PUMPFUN_PROGRAM_ID: PublicKey;
+/** Event Authority for PumpFun */
+declare const PUMPFUN_EVENT_AUTHORITY: PublicKey;
+/** Fee Program */
+declare const PUMPFUN_FEE_PROGRAM: PublicKey;
+/** Global Volume Accumulator */
+declare const PUMPFUN_GLOBAL_VOLUME_ACCUMULATOR: PublicKey;
+/** Fee Config */
+declare const PUMPFUN_FEE_CONFIG: PublicKey;
+/** Global Account */
+declare const PUMPFUN_GLOBAL_ACCOUNT: PublicKey;
+/** Fee Recipient */
+declare const PUMPFUN_FEE_RECIPIENT: PublicKey;
+/** Non-mayhem: random among primary + Pump.fun AMM protocol fee recipients (Rust `get_standard_fee_recipient_meta_random`). */
+declare const PUMPFUN_STANDARD_FEE_RECIPIENTS: PublicKey[];
+/**
+ * Protocol extra fee recipients (Apr 2026 breaking upgrade).
+ * One pubkey is appended after bonding-curve-v2 on buy/sell; account must be writable.
+ * @see https://github.com/pump-fun/pump-public-docs/blob/main/docs/BREAKING_FEE_RECIPIENT.md
+ */
+declare const PUMPFUN_PROTOCOL_EXTRA_FEE_RECIPIENTS: PublicKey[];
+/** V2 buyback fee recipients (same static pool as Rust `get_buyback_fee_recipient_random`). */
+declare const PUMPFUN_BUYBACK_FEE_RECIPIENTS: PublicKey[];
+/** Mayhem Fee Recipients */
+declare const PUMPFUN_MAYHEM_FEE_RECIPIENTS: PublicKey[];
+/** Buy instruction discriminator */
+declare const PUMPFUN_BUY_DISCRIMINATOR: Buffer;
+/** Buy exact SOL in discriminator */
+declare const PUMPFUN_BUY_EXACT_SOL_IN_DISCRIMINATOR: Buffer;
+/** Sell instruction discriminator */
+declare const PUMPFUN_SELL_DISCRIMINATOR: Buffer;
+/** PumpFun V2 buy instruction discriminator */
+declare const PUMPFUN_BUY_V2_DISCRIMINATOR: Buffer;
+/** PumpFun V2 sell instruction discriminator */
+declare const PUMPFUN_SELL_V2_DISCRIMINATOR: Buffer;
+/** PumpFun V2 exact quote-in buy discriminator */
+declare const PUMPFUN_BUY_EXACT_QUOTE_IN_V2_DISCRIMINATOR: Buffer;
+/** Claim cashback discriminator */
+declare const PUMPFUN_CLAIM_CASHBACK_DISCRIMINATOR: Buffer;
+declare const PUMPFUN_BONDING_CURVE_SEED: Buffer<ArrayBuffer>;
+declare const PUMPFUN_BONDING_CURVE_V2_SEED: Buffer<ArrayBuffer>;
+declare const PUMPFUN_CREATOR_VAULT_SEED: Buffer<ArrayBuffer>;
+declare const PUMPFUN_USER_VOLUME_ACCUMULATOR_SEED: Buffer<ArrayBuffer>;
+declare const PUMPFUN_SHARING_CONFIG_SEED: Buffer<ArrayBuffer>;
+/**
+ * Derive the bonding curve PDA for a given mint
+ */
+declare function getBondingCurvePda(mint: PublicKey): PublicKey;
+/**
+ * Derive the bonding curve v2 PDA for a given mint
+ */
+declare function getBondingCurveV2Pda(mint: PublicKey): PublicKey;
+/**
+ * Derive the creator vault PDA for a given creator
+ */
+declare function getCreatorVaultPda(creator: PublicKey): PublicKey;
+/**
+ * Derive the user volume accumulator PDA for a given user
+ */
+declare function getPumpFunUserVolumeAccumulatorPda(user: PublicKey): PublicKey;
+/**
+ * Derive the fee sharing config PDA for a PumpFun mint.
+ */
+declare function getPumpFunFeeSharingConfigPda(mint: PublicKey): PublicKey;
+/**
+ * Get a random Mayhem fee recipient
+ */
+declare function getRandomMayhemFeeRecipient(): PublicKey;
+declare function getStandardFeeRecipientRandom(): PublicKey;
+/** Random protocol extra fee recipient (after bonding-curve-v2, mutable). */
+declare function getPumpFunProtocolExtraFeeRecipientRandom(): PublicKey;
+/** Random PumpFun V2 buyback fee recipient. */
+declare function getPumpFunBuybackFeeRecipientRandom(): PublicKey;
+/**
+ * Account #2 fee recipient: prefer gRPC/event `feeRecipient`; if `default` pubkey, random from mayhem or standard pool (Rust `pump_fun_fee_recipient_meta`).
+ */
+declare function pumpFunFeeRecipientMeta(fromStream: PublicKey | undefined, isMayhemMode: boolean): PublicKey;
+interface PumpFunBondingCurve {
+    account: PublicKey;
+    virtualTokenReserves: bigint;
+    virtualSolReserves: bigint;
+    realTokenReserves: bigint;
+    creator?: PublicKey;
+    isMayhemMode: boolean;
+    isCashbackCoin: boolean;
+}
+interface PumpFunParams$1 {
+    bondingCurve: PumpFunBondingCurve;
+    creatorVault: PublicKey;
+    tokenProgram: PublicKey;
+    associatedBondingCurve?: PublicKey;
+    observedTradeCreator?: PublicKey;
+    feeSharingCreatorVaultIfActive?: PublicKey;
+    closeTokenAccountWhenSell?: boolean;
+    /** From parser/gRPC (`tradeEvent.feeRecipient`); default pubkey → random pool */
+    feeRecipient?: PublicKey;
+    /** Quote mint for V2 instructions; default means WSOL. */
+    quoteMint?: PublicKey;
+    /** Per-params V2 toggle; global `TradeConfig.usePumpfunV2` also maps here. */
+    useV2Ix?: boolean;
+}
+interface PumpFunBuildBuyParams {
+    payer: Keypair | PublicKey;
+    outputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createOutputMintAta?: boolean;
+    createInputMintAta?: boolean;
+    protocolParams: PumpFunParams$1;
+    useExactSolAmount?: boolean;
+    usePumpFunV2?: boolean;
+}
+interface PumpFunBuildSellParams {
+    payer: Keypair | PublicKey;
+    inputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: PumpFunParams$1;
+    usePumpFunV2?: boolean;
+}
+/**
+ * Build buy instructions for PumpFun protocol
+ * 100% port from Rust: src/instruction/pumpfun.rs build_buy_instructions
+ */
+declare function buildPumpFunBuyInstructions(params: PumpFunBuildBuyParams): TransactionInstruction[];
+/**
+ * Build sell instructions for PumpFun protocol
+ * 100% port from Rust: src/instruction/pumpfun.rs build_sell_instructions
+ */
+declare function buildPumpFunSellInstructions(params: PumpFunBuildSellParams): TransactionInstruction[];
+/**
+ * Build PumpFun V2 buy instructions (`buy_v2` / `buy_exact_quote_in_v2`).
+ */
+declare function buildPumpFunBuyV2Instructions(params: PumpFunBuildBuyParams): TransactionInstruction[];
+/**
+ * Build PumpFun V2 sell instructions (`sell_v2`).
+ */
+declare function buildPumpFunSellV2Instructions(params: PumpFunBuildSellParams): TransactionInstruction[];
+/**
+ * Build claim cashback instruction for PumpFun
+ */
+declare function buildPumpFunClaimCashbackInstruction(payer: PublicKey): TransactionInstruction;
+/**
+ * Fetch bonding curve account from RPC.
+ * 100% from Rust: src/instruction/utils/pumpfun.rs fetch_bonding_curve_account
+ */
+declare function fetchBondingCurveAccount(connection: {
+    getAccountInfo: (pubkey: PublicKey) => Promise<{
+        value?: {
+            data: Buffer;
+        };
+    }>;
+}, mint: PublicKey): Promise<{
+    bondingCurve: PumpFunBondingCurve;
+    bondingCurvePda: PublicKey;
+} | null>;
+/**
+ * Get creator from creator vault PDA.
+ * 100% from Rust: src/instruction/utils/pumpfun.rs get_creator
+ */
+declare function getCreator(creatorVaultPda: PublicKey): PublicKey;
+/**
+ * Get buy price (tokens received for SOL).
+ * 100% from Rust: src/instruction/utils/pumpfun.rs get_buy_price
+ */
+declare function getBuyPrice(amount: bigint, virtualSolReserves: bigint, virtualTokenReserves: bigint, realTokenReserves: bigint): bigint;
+
+/**
+ * PumpSwap instruction builder - Production-grade implementation
+ * 100% port from Rust sol-trade-sdk
+ */
+
+declare const PUMPSWAP_PROGRAM: PublicKey;
+declare const PUMPSWAP_PUMP_PROGRAM_ID: PublicKey;
+declare const PUMPSWAP_FEE_PROGRAM: PublicKey;
+declare const PUMPSWAP_FEE_RECIPIENT: PublicKey;
+declare const PUMPSWAP_GLOBAL_ACCOUNT: PublicKey;
+declare const PUMPSWAP_EVENT_AUTHORITY: PublicKey;
+declare const PUMPSWAP_GLOBAL_VOLUME_ACCUMULATOR: PublicKey;
+declare const PUMPSWAP_FEE_CONFIG: PublicKey;
+declare const PUMPSWAP_DEFAULT_COIN_CREATOR_VAULT_AUTHORITY: PublicKey;
+declare const PUMPSWAP_MAYHEM_FEE_RECIPIENTS: PublicKey[];
+/** Protocol extra fee recipients (Apr 2026); after pool-v2: readonly, then quote ATA (mutable). */
+declare const PUMPSWAP_PROTOCOL_EXTRA_FEE_RECIPIENTS: PublicKey[];
+declare const PUMPSWAP_BUY_DISCRIMINATOR: Buffer<ArrayBuffer>;
+declare const PUMPSWAP_BUY_EXACT_QUOTE_IN_DISCRIMINATOR: Buffer<ArrayBuffer>;
+declare const PUMPSWAP_SELL_DISCRIMINATOR: Buffer<ArrayBuffer>;
+declare const PUMPSWAP_CLAIM_CASHBACK_DISCRIMINATOR: Buffer<ArrayBuffer>;
+/**
+ * Get a random Mayhem fee recipient
+ */
+declare function getMayhemFeeRecipientRandom(): PublicKey;
+declare function getPumpSwapProtocolExtraFeeRecipientRandom(): PublicKey;
+/**
+ * Pool v2 PDA (seeds: ["pool-v2", base_mint])
+ */
+declare function getPoolV2PDA(baseMint: PublicKey): PublicKey;
+/**
+ * Pump program pool-authority PDA (for canonical pool)
+ */
+declare function getPumpPoolAuthorityPDA(mint: PublicKey): PublicKey;
+/**
+ * Canonical Pump pool PDA
+ */
+declare function getCanonicalPoolPDA(mint: PublicKey): PublicKey;
+/**
+ * Coin creator vault authority PDA
+ */
+declare function getCoinCreatorVaultAuthority(coinCreator: PublicKey): PublicKey;
+/**
+ * Coin creator vault ATA
+ */
+declare function getCoinCreatorVaultAta(coinCreator: PublicKey, quoteMint: PublicKey): PublicKey;
+/**
+ * Fee recipient ATA
+ */
+declare function getFeeRecipientAta(feeRecipient: PublicKey, quoteMint: PublicKey): PublicKey;
+/**
+ * User volume accumulator PDA
+ */
+declare function getUserVolumeAccumulatorPDA(user: PublicKey): PublicKey;
+/**
+ * WSOL ATA of UserVolumeAccumulator (for buy cashback)
+ */
+declare function getUserVolumeAccumulatorWsolAta(user: PublicKey): PublicKey;
+/**
+ * Quote-mint ATA of UserVolumeAccumulator (for sell cashback)
+ */
+declare function getUserVolumeAccumulatorQuoteAta(user: PublicKey, quoteMint: PublicKey, quoteTokenProgram: PublicKey): PublicKey;
+/**
+ * Global volume accumulator PDA
+ * Seeds: ["global_volume_accumulator"], owner: PUMPSWAP_PROGRAM
+ */
+declare function getGlobalVolumeAccumulatorPDA(): PublicKey;
+/**
+ * Get associated token address
+ */
+declare function getAssociatedTokenAddress(owner: PublicKey, mint: PublicKey, tokenProgram?: PublicKey): PublicKey;
+/**
+ * Create WSOL ATA and wrap SOL
+ * Returns instructions for: create ATA (idempotent), transfer SOL, sync_native
+ */
+declare function handleWsol(owner: PublicKey, amount: bigint): TransactionInstruction[];
+/**
+ * Close WSOL ATA and reclaim rent
+ */
+declare function closeWsol(owner: PublicKey): TransactionInstruction;
+/**
+ * Create associated token account idempotent
+ */
+declare function createAssociatedTokenAccountIdempotent(payer: PublicKey, owner: PublicKey, mint: PublicKey, tokenProgram?: PublicKey): TransactionInstruction;
+interface PumpSwapParams$1 {
+    pool: PublicKey;
+    baseMint: PublicKey;
+    quoteMint: PublicKey;
+    poolBaseTokenAccount: PublicKey;
+    poolQuoteTokenAccount: PublicKey;
+    poolBaseTokenReserves: bigint;
+    poolQuoteTokenReserves: bigint;
+    coinCreatorVaultAta: PublicKey;
+    coinCreatorVaultAuthority: PublicKey;
+    baseTokenProgram: PublicKey;
+    quoteTokenProgram: PublicKey;
+    isMayhemMode: boolean;
+    isCashbackCoin: boolean;
+}
+interface BuildBuyParams {
+    payer: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints: bigint;
+    protocolParams: PumpSwapParams$1;
+    createInputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    createOutputMintAta?: boolean;
+    useExactQuoteAmount?: boolean;
+    fixedOutputAmount?: bigint;
+}
+interface BuildSellParams {
+    payer: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints: bigint;
+    protocolParams: PumpSwapParams$1;
+    createOutputMintAta?: boolean;
+    closeOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    fixedOutputAmount?: bigint;
+}
+/**
+ * Build buy instructions for PumpSwap
+ * 100% port from Rust: src/instruction/pumpswap.rs build_buy_instructions
+ */
+declare function buildBuyInstructions(params: BuildBuyParams): TransactionInstruction[];
+/**
+ * Build sell instructions for PumpSwap
+ * 100% port from Rust: src/instruction/pumpswap.rs build_sell_instructions
+ */
+declare function buildSellInstructions(params: BuildSellParams): TransactionInstruction[];
+/**
+ * Build claim cashback instruction for PumpSwap
+ */
+declare function buildClaimCashbackInstruction(payer: PublicKey, quoteMint: PublicKey, quoteTokenProgram: PublicKey): TransactionInstruction;
+/**
+ * Pool size in bytes (244 bytes as per pump-public-docs)
+ */
+declare const POOL_SIZE = 244;
+/**
+ * PumpSwap Pool structure
+ * Matches Rust: src/instruction/utils/pumpswap_types.rs Pool struct
+ */
+interface PumpSwapPool {
+    poolBump: number;
+    index: number;
+    creator: PublicKey;
+    baseMint: PublicKey;
+    quoteMint: PublicKey;
+    lpMint: PublicKey;
+    poolBaseTokenAccount: PublicKey;
+    poolQuoteTokenAccount: PublicKey;
+    lpSupply: bigint;
+    coinCreator: PublicKey;
+    isMayhemMode: boolean;
+    isCashbackCoin: boolean;
+}
+/**
+ * Decode a PumpSwap pool from account data
+ * Uses Borsh deserialization
+ */
+declare function decodePool(data: Buffer): PumpSwapPool | null;
+/**
+ * Get fee config PDA
+ */
+declare function getFeeConfigPDA(): PublicKey;
+/**
+ * Fetch a PumpSwap pool from RPC.
+ * 100% from Rust: src/instruction/utils/pumpswap.rs fetch_pool
+ */
+declare function fetchPool(connection: {
+    getAccountInfo: (pubkey: PublicKey) => Promise<{
+        value?: {
+            data: Buffer;
+        };
+    }>;
+}, poolAddress: PublicKey): Promise<PumpSwapPool | null>;
+/**
+ * Get token balances for a pool's token accounts.
+ * 100% from Rust: src/instruction/utils/pumpswap.rs get_token_balances
+ */
+declare function getTokenBalances(connection: {
+    getTokenAccountBalance: (pubkey: PublicKey) => Promise<{
+        value?: {
+            amount: string;
+        };
+    }>;
+}, pool: PumpSwapPool): Promise<{
+    baseBalance: bigint;
+    quoteBalance: bigint;
+} | null>;
+/**
+ * Find a PumpSwap pool by mint with full RPC lookup.
+ * 100% from Rust: src/instruction/utils/pumpswap.rs find_by_mint
+ * Search order:
+ * 1. Pool v2 PDA ["pool-v2", base_mint]
+ * 2. Canonical pool PDA
+ * 3. getProgramAccounts by base_mint / quote_mint (optional fallback)
+ */
+declare function findByMint(connection: {
+    getAccountInfo: (pubkey: PublicKey) => Promise<{
+        value?: {
+            data: Buffer;
+        };
+    }>;
+    getProgramAccounts?: (programId: PublicKey, config?: unknown) => Promise<Array<{
+        pubkey: PublicKey;
+        account: {
+            data: Buffer;
+        };
+    }>>;
+}, mint: PublicKey): Promise<{
+    poolAddress: PublicKey;
+    pool: PumpSwapPool;
+} | null>;
+/**
+ * Find a PumpSwap pool by base mint using getProgramAccounts.
+ * 100% from Rust: src/instruction/utils/pumpswap.rs find_by_base_mint
+ * base_mint offset: 8(discriminator) + 1(bump) + 2(index) + 32(creator) = 43
+ */
+declare function findByBaseMint(connection: {
+    getProgramAccounts: (programId: PublicKey, config?: {
+        filters?: Array<{
+            dataSize?: number;
+            memcmp?: {
+                offset: number;
+                bytes: string;
+            };
+        }>;
+        encoding?: string;
+    }) => Promise<Array<{
+        pubkey: PublicKey;
+        account: {
+            data: Buffer;
+        };
+    }>>;
+}, baseMint: PublicKey): Promise<{
+    poolAddress: PublicKey;
+    pool: PumpSwapPool;
+} | null>;
+/**
+ * Find a PumpSwap pool by quote mint using getProgramAccounts.
+ * 100% from Rust: src/instruction/utils/pumpswap.rs find_by_quote_mint
+ * quote_mint offset: 8 + 1 + 2 + 32 + 32 = 75
+ */
+declare function findByQuoteMint(connection: {
+    getProgramAccounts: (programId: PublicKey, config?: {
+        filters?: Array<{
+            dataSize?: number;
+            memcmp?: {
+                offset: number;
+                bytes: string;
+            };
+        }>;
+        encoding?: string;
+    }) => Promise<Array<{
+        pubkey: PublicKey;
+        account: {
+            data: Buffer;
+        };
+    }>>;
+}, quoteMint: PublicKey): Promise<{
+    poolAddress: PublicKey;
+    pool: PumpSwapPool;
+} | null>;
+
+/**
+ * Bonk Protocol Instruction Builder
+ *
+ * Production-grade instruction builder for Bonk AMM protocol.
+ * Supports buy and sell operations with WSOL and USD1 pools.
+ * 100% port from Rust: src/instruction/bonk.rs
+ */
+
+/** Bonk program ID */
+declare const BONK_PROGRAM_ID: PublicKey;
+/** Bonk Authority */
+declare const BONK_AUTHORITY: PublicKey;
+/** Bonk Global Config */
+declare const BONK_GLOBAL_CONFIG: PublicKey;
+/** Bonk USD1 Global Config */
+declare const BONK_USD1_GLOBAL_CONFIG: PublicKey;
+/** Bonk Event Authority */
+declare const BONK_EVENT_AUTHORITY: PublicKey;
+/** WSOL Token Account (mint) */
+declare const WSOL_MINT: PublicKey;
+/** USD1 Token Account (mint) */
+declare const USD1_MINT: PublicKey;
+/** USDC Token Account (mint) */
+declare const USDC_MINT: PublicKey;
+/** Fee rates - from Rust */
+declare const BONK_PLATFORM_FEE_RATE: bigint;
+declare const BONK_PROTOCOL_FEE_RATE: bigint;
+declare const BONK_SHARE_FEE_RATE: bigint;
+/** Buy exact in instruction discriminator */
+declare const BONK_BUY_EXACT_IN_DISCRIMINATOR: Buffer;
+/** Sell exact in instruction discriminator */
+declare const BONK_SELL_EXACT_IN_DISCRIMINATOR: Buffer;
+declare const BONK_POOL_SEED: Buffer<ArrayBuffer>;
+declare const BONK_POOL_VAULT_SEED: Buffer<ArrayBuffer>;
+/**
+ * Derive the pool PDA for given base and quote mints
+ */
+declare function getBonkPoolPda(baseMint: PublicKey, quoteMint: PublicKey): PublicKey;
+/**
+ * Derive the vault PDA for given pool and mint
+ */
+declare function getBonkVaultPda(poolState: PublicKey, mint: PublicKey): PublicKey;
+/**
+ * Get platform associated account PDA
+ */
+declare function getBonkPlatformAssociatedAccount(platformConfig: PublicKey): PublicKey;
+/**
+ * Get creator associated account PDA
+ */
+declare function getBonkCreatorAssociatedAccount(creator: PublicKey): PublicKey;
+interface BonkParams$1 {
+    poolState: PublicKey;
+    baseVault: PublicKey;
+    quoteVault: PublicKey;
+    virtualBase: bigint;
+    virtualQuote: bigint;
+    realBase: bigint;
+    realQuote: bigint;
+    mintTokenProgram: PublicKey;
+    platformConfig: PublicKey;
+    platformAssociatedAccount: PublicKey;
+    creatorAssociatedAccount: PublicKey;
+    globalConfig?: PublicKey;
+}
+interface BonkBuildBuyParams {
+    payer: Keypair | PublicKey;
+    outputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createInputMintAta?: boolean;
+    createOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: BonkParams$1;
+}
+interface BonkBuildSellParams {
+    payer: Keypair | PublicKey;
+    inputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createOutputMintAta?: boolean;
+    closeOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: BonkParams$1;
+}
+/**
+ * Build buy instructions for Bonk protocol
+ * 100% port from Rust: src/instruction/bonk.rs build_buy_instructions
+ */
+declare function buildBonkBuyInstructions(params: BonkBuildBuyParams): TransactionInstruction[];
+/**
+ * Build sell instructions for Bonk protocol
+ * 100% port from Rust: src/instruction/bonk.rs build_sell_instructions
+ */
+declare function buildBonkSellInstructions(params: BonkBuildSellParams): TransactionInstruction[];
+declare const BONK_POOL_STATE_SIZE = 421;
+interface BonkVestingSchedule {
+    totalLockedAmount: bigint;
+    cliffPeriod: bigint;
+    unlockPeriod: bigint;
+    startTime: bigint;
+    allocatedShareAmount: bigint;
+}
+interface BonkPoolState {
+    epoch: bigint;
+    authBump: number;
+    status: number;
+    baseDecimals: number;
+    quoteDecimals: number;
+    migrateType: number;
+    supply: bigint;
+    totalBaseSell: bigint;
+    virtualBase: bigint;
+    virtualQuote: bigint;
+    realBase: bigint;
+    realQuote: bigint;
+    totalQuoteFundRaising: bigint;
+    quoteProtocolFee: bigint;
+    platformFee: bigint;
+    migrateFee: bigint;
+    vestingSchedule: BonkVestingSchedule;
+    globalConfig: PublicKey;
+    platformConfig: PublicKey;
+    baseMint: PublicKey;
+    quoteMint: PublicKey;
+    baseVault: PublicKey;
+    quoteVault: PublicKey;
+    creator: PublicKey;
+}
+/**
+ * Decode a Bonk pool state from account data
+ * 100% from Rust: src/instruction/utils/bonk_types.rs pool_state_decode
+ */
+declare function decodeBonkPoolState(data: Buffer): BonkPoolState | null;
+/**
+ * Fetch a Bonk pool state from RPC.
+ * 100% from Rust: src/instruction/utils/bonk.rs fetch_pool_state
+ */
+declare function fetchBonkPoolState(connection: {
+    getAccountInfo: (pubkey: PublicKey) => Promise<{
+        value?: {
+            data: Buffer;
+        };
+    }>;
+}, poolAddress: PublicKey): Promise<BonkPoolState | null>;
+/**
+ * Get pool PDA for Bonk.
+ * Seeds: ["pool", base_mint, quote_mint]
+ */
+declare function getBonkPoolPDA(baseMint: PublicKey, quoteMint: PublicKey): PublicKey;
+/**
+ * Get vault PDA for Bonk.
+ * Seeds: ["pool_vault", pool_state, mint]
+ */
+declare function getBonkVaultPDA(poolState: PublicKey, mint: PublicKey): PublicKey;
+
+/**
+ * Raydium CPMM (Concentrated Pool Market Maker) Protocol Instruction Builder
+ *
+ * Production-grade instruction builder for Raydium CPMM protocol.
+ * 100% port of Rust implementation.
+ */
+
+/** Raydium CPMM program ID */
+declare const RAYDIUM_CPMM_PROGRAM_ID: PublicKey;
+/** Authority */
+declare const RAYDIUM_CPMM_AUTHORITY: PublicKey;
+/** Fee rates */
+declare const RAYDIUM_CPMM_FEE_RATE_DENOMINATOR_VALUE: bigint;
+declare const RAYDIUM_CPMM_TRADE_FEE_RATE: bigint;
+declare const RAYDIUM_CPMM_CREATOR_FEE_RATE: bigint;
+declare const RAYDIUM_CPMM_PROTOCOL_FEE_RATE: bigint;
+declare const RAYDIUM_CPMM_FUND_FEE_RATE: bigint;
+/** Swap base in instruction discriminator */
+declare const RAYDIUM_CPMM_SWAP_BASE_IN_DISCRIMINATOR: Buffer;
+/** Swap base out instruction discriminator */
+declare const RAYDIUM_CPMM_SWAP_BASE_OUT_DISCRIMINATOR: Buffer;
+declare const RAYDIUM_CPMM_POOL_SEED: Buffer<ArrayBuffer>;
+declare const RAYDIUM_CPMM_POOL_VAULT_SEED: Buffer<ArrayBuffer>;
+declare const RAYDIUM_CPMM_OBSERVATION_STATE_SEED: Buffer<ArrayBuffer>;
+/**
+ * Derive the pool PDA for given config and mints
+ */
+declare function getRaydiumCpmmPoolPda(ammConfig: PublicKey, mint1: PublicKey, mint2: PublicKey): PublicKey;
+/**
+ * Derive the vault PDA for a pool and mint
+ */
+declare function getRaydiumCpmmVaultPda(poolState: PublicKey, mint: PublicKey): PublicKey;
+/**
+ * Derive the observation state PDA for a pool
+ */
+declare function getRaydiumCpmmObservationStatePda(poolState: PublicKey): PublicKey;
+/**
+ * Compute swap amount for CPMM
+ */
+declare function computeRaydiumCpmmSwapAmount(baseReserve: bigint, quoteReserve: bigint, isBaseIn: boolean, amountIn: bigint, slippageBasisPoints: bigint): {
+    amountOut: bigint;
+    minAmountOut: bigint;
+};
+interface RaydiumCpmmParams$1 {
+    poolState?: PublicKey;
+    ammConfig: PublicKey;
+    baseMint: PublicKey;
+    quoteMint: PublicKey;
+    baseTokenProgram: PublicKey;
+    quoteTokenProgram: PublicKey;
+    baseVault?: PublicKey;
+    quoteVault?: PublicKey;
+    baseReserve: bigint;
+    quoteReserve: bigint;
+    observationState?: PublicKey;
+}
+interface BuildRaydiumCpmmBuyInstructionsParams {
+    payer: Keypair | PublicKey;
+    outputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createInputMintAta?: boolean;
+    createOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: RaydiumCpmmParams$1;
+}
+interface BuildRaydiumCpmmSellInstructionsParams {
+    payer: Keypair | PublicKey;
+    inputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createOutputMintAta?: boolean;
+    closeOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: RaydiumCpmmParams$1;
+}
+/**
+ * Build buy instructions for Raydium CPMM protocol
+ */
+declare function buildRaydiumCpmmBuyInstructions(params: BuildRaydiumCpmmBuyInstructionsParams): TransactionInstruction[];
+/**
+ * Build sell instructions for Raydium CPMM protocol
+ */
+declare function buildRaydiumCpmmSellInstructions(params: BuildRaydiumCpmmSellInstructionsParams): TransactionInstruction[];
+declare const RAYDIUM_CPMM_POOL_STATE_SIZE = 629;
+interface RaydiumCPMMpoolState {
+    ammConfig: PublicKey;
+    poolCreator: PublicKey;
+    token0Vault: PublicKey;
+    token1Vault: PublicKey;
+    lpMint: PublicKey;
+    token0Mint: PublicKey;
+    token1Mint: PublicKey;
+    token0Program: PublicKey;
+    token1Program: PublicKey;
+    observationKey: PublicKey;
+    authBump: number;
+    status: number;
+    lpMintDecimals: number;
+    mint0Decimals: number;
+    mint1Decimals: number;
+    lpSupply: bigint;
+    protocolFeesToken0: bigint;
+    protocolFeesToken1: bigint;
+    fundFeesToken0: bigint;
+    fundFeesToken1: bigint;
+    openTime: bigint;
+    recentEpoch: bigint;
+}
+/**
+ * Decode a Raydium CPMM pool state from account data
+ * 100% from Rust: src/instruction/utils/raydium_cpmm_types.rs pool_state_decode
+ */
+declare function decodeRaydiumCPMMpoolState(data: Buffer): RaydiumCPMMpoolState | null;
+/**
+ * Fetch a Raydium CPMM pool state from RPC.
+ * 100% from Rust: src/instruction/utils/raydium_cpmm.rs fetch_pool_state
+ */
+declare function fetchRaydiumCPMMpoolState(connection: {
+    getAccountInfo: (pubkey: PublicKey) => Promise<{
+        value?: {
+            data: Buffer;
+        };
+    }>;
+}, poolAddress: PublicKey): Promise<RaydiumCPMMpoolState | null>;
+/**
+ * Get pool PDA for Raydium CPMM.
+ * Seeds: ["pool", amm_config, mint1, mint2]
+ */
+declare function getRaydiumCPMMpoolPDA(ammConfig: PublicKey, mint1: PublicKey, mint2: PublicKey): PublicKey;
+/**
+ * Get vault PDA for Raydium CPMM.
+ * Seeds: ["pool_vault", pool_state, mint]
+ */
+declare function getRaydiumCPMMvaultPDA(poolState: PublicKey, mint: PublicKey): PublicKey;
+/**
+ * Get observation state PDA for Raydium CPMM.
+ * Seeds: ["observation", pool_state]
+ */
+declare function getRaydiumCPMMobservationStatePDA(poolState: PublicKey): PublicKey;
+/**
+ * Get token balances for a Raydium CPMM pool.
+ * 100% from Rust: src/instruction/utils/raydium_cpmm.rs get_pool_token_balances
+ */
+declare function getRaydiumCPMMpoolTokenBalances(connection: {
+    getTokenAccountBalance: (pubkey: PublicKey) => Promise<{
+        value?: {
+            amount: string;
+        };
+    }>;
+}, poolState: PublicKey, token0Mint: PublicKey, token1Mint: PublicKey): Promise<{
+    token0Balance: bigint;
+    token1Balance: bigint;
+} | null>;
+
+/**
+ * Raydium AMM V4 Protocol Instruction Builder
+ *
+ * Production-grade instruction builder for Raydium AMM V4 protocol.
+ * 100% port of Rust implementation.
+ */
+
+/** Raydium AMM V4 program ID */
+declare const RAYDIUM_AMM_V4_PROGRAM_ID: PublicKey;
+/** Authority */
+declare const RAYDIUM_AMM_V4_AUTHORITY: PublicKey;
+/** Fee rates */
+declare const RAYDIUM_AMM_V4_TRADE_FEE_NUMERATOR: bigint;
+declare const RAYDIUM_AMM_V4_TRADE_FEE_DENOMINATOR: bigint;
+declare const RAYDIUM_AMM_V4_SWAP_FEE_NUMERATOR: bigint;
+declare const RAYDIUM_AMM_V4_SWAP_FEE_DENOMINATOR: bigint;
+/** Swap base in instruction discriminator (single byte) */
+declare const RAYDIUM_AMM_V4_SWAP_BASE_IN_DISCRIMINATOR: Buffer;
+/** Swap base out instruction discriminator (single byte) */
+declare const RAYDIUM_AMM_V4_SWAP_BASE_OUT_DISCRIMINATOR: Buffer;
+declare const RAYDIUM_AMM_V4_POOL_SEED: Buffer<ArrayBuffer>;
+/**
+ * Compute swap amount for AMM V4
+ */
+declare function computeRaydiumAmmV4SwapAmount(coinReserve: bigint, pcReserve: bigint, isCoinIn: boolean, amountIn: bigint, slippageBasisPoints: bigint): {
+    amountOut: bigint;
+    minAmountOut: bigint;
+};
+interface RaydiumAmmV4Params$1 {
+    amm: PublicKey;
+    coinMint: PublicKey;
+    pcMint: PublicKey;
+    tokenCoin: PublicKey;
+    tokenPc: PublicKey;
+    coinReserve: bigint;
+    pcReserve: bigint;
+}
+interface BuildRaydiumAmmV4BuyInstructionsParams {
+    payer: Keypair | PublicKey;
+    outputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createInputMintAta?: boolean;
+    createOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: RaydiumAmmV4Params$1;
+}
+interface BuildRaydiumAmmV4SellInstructionsParams {
+    payer: Keypair | PublicKey;
+    inputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createOutputMintAta?: boolean;
+    closeOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: RaydiumAmmV4Params$1;
+}
+/**
+ * Build buy instructions for Raydium AMM V4 protocol
+ */
+declare function buildRaydiumAmmV4BuyInstructions(params: BuildRaydiumAmmV4BuyInstructionsParams): TransactionInstruction[];
+/**
+ * Build sell instructions for Raydium AMM V4 protocol
+ */
+declare function buildRaydiumAmmV4SellInstructions(params: BuildRaydiumAmmV4SellInstructionsParams): TransactionInstruction[];
+declare const AMM_INFO_SIZE = 752;
+interface RaydiumAmmFees {
+    minSeparateNumerator: bigint;
+    minSeparateDenominator: bigint;
+    tradeFeeNumerator: bigint;
+    tradeFeeDenominator: bigint;
+    pnlNumerator: bigint;
+    pnlDenominator: bigint;
+    swapFeeNumerator: bigint;
+    swapFeeDenominator: bigint;
+}
+interface RaydiumAmmOutputData {
+    needTakePnlCoin: bigint;
+    needTakePnlPc: bigint;
+    totalPnlPc: bigint;
+    totalPnlCoin: bigint;
+    poolOpenTime: bigint;
+    punishPcAmount: bigint;
+    punishCoinAmount: bigint;
+    orderbookToInitTime: bigint;
+    swapCoinInAmount: bigint;
+    swapPcOutAmount: bigint;
+    swapTakePcFee: bigint;
+    swapPcInAmount: bigint;
+    swapCoinOutAmount: bigint;
+    swapTakeCoinFee: bigint;
+}
+interface RaydiumAmmInfo {
+    status: bigint;
+    nonce: bigint;
+    orderNum: bigint;
+    depth: bigint;
+    coinDecimals: bigint;
+    pcDecimals: bigint;
+    state: bigint;
+    resetFlag: bigint;
+    minSize: bigint;
+    volMaxCutRatio: bigint;
+    amountWave: bigint;
+    coinLotSize: bigint;
+    pcLotSize: bigint;
+    minPriceMultiplier: bigint;
+    maxPriceMultiplier: bigint;
+    sysDecimalValue: bigint;
+    fees: RaydiumAmmFees;
+    output: RaydiumAmmOutputData;
+    tokenCoin: PublicKey;
+    tokenPc: PublicKey;
+    coinMint: PublicKey;
+    pcMint: PublicKey;
+    lpMint: PublicKey;
+    openOrders: PublicKey;
+    market: PublicKey;
+    serumDex: PublicKey;
+    targetOrders: PublicKey;
+    withdrawQueue: PublicKey;
+    tokenTempLp: PublicKey;
+    ammOwner: PublicKey;
+    lpAmount: bigint;
+    clientOrderId: bigint;
+}
+/**
+ * Decode Raydium AMM v4 info from account data.
+ * 100% from Rust: src/instruction/utils/raydium_amm_v4_types.rs amm_info_decode
+ */
+declare function decodeAmmInfo(data: Buffer): RaydiumAmmInfo | null;
+/**
+ * Fetch AMM info from RPC.
+ * 100% from Rust: src/instruction/utils/raydium_amm_v4.rs fetch_amm_info
+ */
+declare function fetchAmmInfo(connection: {
+    getAccountInfo: (pubkey: PublicKey) => Promise<{
+        value?: {
+            data: Buffer;
+        };
+    }>;
+}, amm: PublicKey): Promise<RaydiumAmmInfo | null>;
+
+/**
+ * Meteora DAMM V2 Protocol Instruction Builder
+ *
+ * Production-grade instruction builder for Meteora DAMM V2 protocol.
+ * 100% port of Rust implementation.
+ */
+
+/** Meteora DAMM V2 program ID */
+declare const METEORA_DAMM_V2_PROGRAM_ID: PublicKey;
+/** Authority */
+declare const METEORA_DAMM_V2_AUTHORITY: PublicKey;
+/** Swap instruction discriminator */
+declare const METEORA_DAMM_V2_SWAP_DISCRIMINATOR: Buffer;
+declare const METEORA_DAMM_V2_EVENT_AUTHORITY_SEED: Buffer<ArrayBuffer>;
+/**
+ * Derive the event authority PDA
+ */
+declare function getMeteoraDammV2EventAuthorityPda(): PublicKey;
+interface MeteoraDammV2Params$1 {
+    pool: PublicKey;
+    tokenAMint: PublicKey;
+    tokenBMint: PublicKey;
+    tokenAVault: PublicKey;
+    tokenBVault: PublicKey;
+    tokenAProgram: PublicKey;
+    tokenBProgram: PublicKey;
+}
+interface BuildMeteoraDammV2BuyInstructionsParams {
+    payer: Keypair | PublicKey;
+    inputMint: PublicKey;
+    outputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createInputMintAta?: boolean;
+    createOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: MeteoraDammV2Params$1;
+}
+interface BuildMeteoraDammV2SellInstructionsParams {
+    payer: Keypair | PublicKey;
+    inputMint: PublicKey;
+    outputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createOutputMintAta?: boolean;
+    closeOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: MeteoraDammV2Params$1;
+}
+/**
+ * Build buy instructions for Meteora DAMM V2 protocol
+ */
+declare function buildMeteoraDammV2BuyInstructions(params: BuildMeteoraDammV2BuyInstructionsParams): TransactionInstruction[];
+/**
+ * Build sell instructions for Meteora DAMM V2 protocol
+ */
+declare function buildMeteoraDammV2SellInstructions(params: BuildMeteoraDammV2SellInstructionsParams): TransactionInstruction[];
+/** Pool size in bytes */
+declare const METEORA_POOL_SIZE = 1104;
+/**
+ * Meteora DAMM V2 Pool structure (simplified for essential fields)
+ * 100% from Rust: src/instruction/utils/meteora_damm_v2_types.rs Pool
+ */
+interface MeteoraDammV2Pool {
+    tokenAMint: PublicKey;
+    tokenBMint: PublicKey;
+    tokenAVault: PublicKey;
+    tokenBVault: PublicKey;
+    liquidity: bigint;
+    sqrtPrice: bigint;
+    poolStatus: number;
+    tokenAFlag: number;
+    tokenBFlag: number;
+}
+/**
+ * Decode a Meteora DAMM V2 pool from account data.
+ * 100% from Rust: src/instruction/utils/meteora_damm_v2_types.rs pool_decode
+ */
+declare function decodeMeteoraPool(data: Buffer): MeteoraDammV2Pool | null;
+/**
+ * Fetch a Meteora DAMM V2 pool from RPC.
+ * 100% from Rust: src/instruction/utils/meteora_damm_v2.rs fetch_pool
+ */
+declare function fetchMeteoraPool(connection: {
+    getAccountInfo: (pubkey: PublicKey) => Promise<{
+        value?: {
+            data: Buffer;
+            owner?: PublicKey;
+        };
+    }>;
+}, poolAddress: PublicKey): Promise<MeteoraDammV2Pool | null>;
+
+/**
+ * Utility functions for Sol Trade SDK
+ */
+
+/**
+ * Calculate amount with slippage for buy operations
+ *
+ * Note: Basis points are clamped to MAX_SLIPPAGE_BASIS_POINTS (9999 = 99.99%)
+ * to prevent the amount from doubling when slippageBasisPoints = 10000.
+ */
+declare function calculateWithSlippageBuy(amount: bigint, slippageBasisPoints: number): bigint;
+/**
+ * Calculate amount with slippage for sell operations
+ */
+declare function calculateWithSlippageSell(amount: bigint, slippageBasisPoints: number): bigint;
+/**
+ * Calculate buy token amount from SOL amount for PumpFun
+ */
+declare function getBuyTokenAmountFromSolAmount(virtualTokenReserves: bigint, virtualSolReserves: bigint, _realTokenReserves: bigint, _creatorFee: number, solAmount: bigint): bigint;
+/**
+ * Calculate sell SOL amount from token amount for PumpFun
+ */
+declare function getSellSolAmountFromTokenAmount(virtualTokenReserves: bigint, virtualSolReserves: bigint, _creatorFee: number, tokenAmount: bigint): bigint;
+/**
+ * Convert lamports to SOL
+ */
+declare function lamportsToSol(lamports: number | bigint): number;
+/**
+ * Convert SOL to lamports
+ */
+declare function solToLamports(sol: number): bigint;
+/**
+ * Get current timestamp in microseconds
+ */
+declare function nowMicroseconds(): bigint;
+/**
+ * Validate public key string
+ */
+declare function isValidPublicKey(key: string): boolean;
+/**
+ * Sleep for specified milliseconds
+ */
+declare function sleep(ms: number): Promise<void>;
+/**
+ * Format public key for display (truncated)
+ */
+declare function formatPublicKey(key: PublicKey | string, chars?: number): string;
+/**
+ * Calculate price impact percentage
+ */
+declare function calculatePriceImpact(reserveIn: bigint, amountIn: bigint): number;
+/**
+ * Retry a function with exponential backoff
+ */
+declare function retryWithBackoff<T>(fn: () => Promise<T>, maxRetries?: number, baseDelayMs?: number): Promise<T>;
+
+/**
+ * Hot Path State Management for Sol Trade SDK
+ *
+ * Manages prefetched blockchain state for zero-latency trading execution.
+ * NO RPC calls are made during trading - all data is prefetched.
+ *
+ * Key principle: Prepare everything before the trade, execute with minimal latency.
+ */
+
+interface HotPathConfig {
+    blockhashRefreshIntervalMs: number;
+    cacheTtlMs: number;
+    enablePrefetch: boolean;
+    prefetchTimeoutMs: number;
+}
+declare function defaultHotPathConfig(): HotPathConfig;
+interface PrefetchedData {
+    blockhash: string;
+    lastValidBlockHeight: number;
+    slot: number;
+    fetchedAt: number;
+}
+interface AccountState {
+    pubkey: string;
+    data: Buffer;
+    lamports: bigint;
+    owner: string;
+    executable: boolean;
+    rentEpoch: number;
+    slot: number;
+    fetchedAt: number;
+}
+interface PoolState {
+    poolAddress: string;
+    poolType: 'pumpfun' | 'pumpswap' | 'raydium' | 'meteora';
+    mintA: string;
+    mintB: string;
+    vaultA: string;
+    vaultB: string;
+    reserveA: bigint;
+    reserveB: bigint;
+    feeRate: number;
+    fetchedAt: number;
+    rawData?: Buffer;
+}
+declare class HotPathState {
+    private config;
+    private connection;
+    private currentData;
+    private accounts;
+    private pools;
+    private prefetchTimer?;
+    private isRunning;
+    private onBlockhashUpdateCallback?;
+    private metrics;
+    constructor(connection: Connection, config?: Partial<HotPathConfig>);
+    /**
+     * Start background prefetching
+     * Call this BEFORE any hot path execution
+     */
+    start(): Promise<void>;
+    /**
+     * Stop background prefetching
+     */
+    stop(): void;
+    /**
+     * Check if prefetching is active
+     */
+    isActive(): boolean;
+    /**
+     * Prefetch latest blockhash - RPC call happens here (background only)
+     */
+    private prefetchBlockhash;
+    /**
+     * Get current cached blockhash - NO RPC CALL
+     */
+    getBlockhash(): {
+        blockhash: string;
+        lastValidBlockHeight: number;
+    } | null;
+    /**
+     * Check if prefetched data is still valid
+     */
+    isDataFresh(): boolean;
+    /**
+     * Get all prefetched data
+     */
+    getPrefetchedData(): PrefetchedData | null;
+    /**
+     * Set callback for blockhash updates
+     */
+    onBlockhashUpdate(callback: (blockhash: string, lastValidBlockHeight: number) => void): void;
+    /**
+     * Update account state in cache
+     */
+    updateAccount(pubkey: string, state: AccountState): void;
+    /**
+     * Get account state from cache - NO RPC CALL
+     */
+    getAccount(pubkey: string): AccountState | null;
+    /**
+     * Get multiple account states - NO RPC CALL
+     */
+    getAccounts(pubkeys: string[]): Map<string, AccountState>;
+    /**
+     * Prefetch accounts - RPC call happens here (before trading)
+     * Call this BEFORE entering the hot path
+     */
+    prefetchAccounts(pubkeys: string[]): Promise<void>;
+    /**
+     * Update pool state in cache
+     */
+    updatePool(poolAddress: string, state: PoolState): void;
+    /**
+     * Get pool state from cache - NO RPC CALL
+     */
+    getPool(poolAddress: string): PoolState | null;
+    getMetrics(): {
+        prefetchCount: number;
+        prefetchErrors: number;
+        lastPrefetchTime: number;
+        accountsCached: number;
+        poolsCached: number;
+        dataFresh: boolean;
+    };
+}
+/**
+ * Trading context with all prefetched data needed for a trade.
+ * Created BEFORE hot path execution, contains all necessary state.
+ * NO RPC calls during trade execution.
+ */
+declare class TradingContext {
+    readonly payer: string;
+    readonly blockhash: string;
+    readonly lastValidBlockHeight: number;
+    readonly createdAt: number;
+    readonly accountStates: Map<string, AccountState>;
+    readonly poolStates: Map<string, PoolState>;
+    constructor(hotPathState: HotPathState, payer: string);
+    /**
+     * Add account state from cache
+     */
+    addAccount(pubkey: string, hotPathState: HotPathState): boolean;
+    /**
+     * Add pool state from cache
+     */
+    addPool(poolAddress: string, hotPathState: HotPathState): boolean;
+    /**
+     * Get age of context in milliseconds
+     */
+    age(): number;
+    /**
+     * Check if context is still valid
+     */
+    isValid(maxAgeMs?: number): boolean;
+    /**
+     * Get token account data from context
+     */
+    getTokenAccountData(pubkey: string): Buffer | undefined;
+}
+declare class HotPathError extends Error {
+    constructor(message: string);
+}
+declare class StaleBlockhashError extends HotPathError {
+    constructor(message?: string);
+}
+declare class MissingAccountError extends HotPathError {
+    constructor(message?: string);
+}
+declare class ContextExpiredError extends HotPathError {
+    constructor(message?: string);
+}
+
+/**
+ * SWQOS Clients for Sol Trade SDK
+ * Implements various SWQOS (Solana Write Queue Operating System) providers.
+ */
+
+interface SwqosClient {
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    sendTransactions(tradeType: TradeType, transactions: Buffer[], waitConfirmation: boolean): Promise<string[]>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+
+/**
+ * Hot Path Executor for Sol Trade SDK
+ *
+ * Executes trades with ZERO RPC calls in the hot path.
+ * All data must be prefetched before execution.
+ *
+ * Key principle: Prepare everything, then execute with minimal latency.
+ */
+
+interface ExecuteOptions {
+    parallelSubmit: boolean;
+    timeoutMs: number;
+    skipBlockhashValidation: boolean;
+    maxRetries: number;
+}
+declare function defaultExecuteOptions(): ExecuteOptions;
+interface ExecuteResult {
+    signature: string;
+    success: boolean;
+    error?: string;
+    latencyMs: number;
+    swqosType?: SwqosType;
+    blockhashUsed: string;
+}
+interface GasFeeConfig {
+    computeUnitLimit: number;
+    computeUnitPrice: number;
+}
+declare class HotPathMetrics {
+    private totalTrades;
+    private successTrades;
+    private failedTrades;
+    private totalLatencyMs;
+    record(success: boolean, latencyMs: number): void;
+    getStats(): {
+        totalTrades: number;
+        successTrades: number;
+        failedTrades: number;
+        avgLatencyMs: number;
+    };
+}
+/**
+ * Executes trades with ZERO RPC calls in the hot path.
+ *
+ * Usage:
+ *   1. Create executor with RPC connection
+ *   2. Call start() to begin background prefetching
+ *   3. Prefetch required accounts/pools BEFORE trading
+ *   4. Build transaction with prefetched blockhash
+ *   5. Execute - no RPC calls during this phase
+ */
+declare class HotPathExecutor {
+    private state;
+    private config;
+    private connection;
+    private swqosClients;
+    private metrics;
+    constructor(connection: Connection, config?: Partial<HotPathConfig>);
+    /**
+     * Add a SWQoS client for transaction submission
+     */
+    addSwqosClient(client: SwqosClient): void;
+    /**
+     * Remove a SWQoS client
+     */
+    removeSwqosClient(swqosType: SwqosType): void;
+    /**
+     * Get SWQoS client by type
+     */
+    getSwqosClient(swqosType: SwqosType): SwqosClient | undefined;
+    /**
+     * Start background prefetching
+     */
+    start(): Promise<void>;
+    /**
+     * Stop background prefetching
+     */
+    stop(): void;
+    /**
+     * Get hot path state for external access
+     */
+    getState(): HotPathState;
+    /**
+     * Check if executor is ready for hot path execution
+     */
+    isReady(): boolean;
+    /**
+     * Wait until executor is ready
+     */
+    waitForReady(checkIntervalMs?: number, timeoutMs?: number): Promise<boolean>;
+    /**
+     * Prefetch accounts - call BEFORE hot path execution
+     */
+    prefetchAccounts(pubkeys: string[]): Promise<void>;
+    /**
+     * Create trading context with prefetched data - NO RPC
+     */
+    createTradingContext(payer: string): TradingContext;
+    /**
+     * Execute a pre-signed transaction - NO RPC CALLS
+     *
+     * Transaction must already be signed with valid blockhash.
+     * All state should be prefetched before calling this.
+     */
+    execute(tradeType: TradeType, transactionBytes: Buffer, opts?: ExecuteOptions): Promise<ExecuteResult>;
+    /**
+     * Submit to all SWQoS clients in parallel - NO RPC
+     */
+    private executeParallel;
+    /**
+     * Submit to SWQoS clients sequentially - NO RPC
+     */
+    private executeSequential;
+    /**
+     * Execute multiple transactions in parallel
+     */
+    executeMultiple(tradeType: TradeType, transactions: Buffer[], opts?: ExecuteOptions): Promise<ExecuteResult[]>;
+    /**
+     * Get cached blockhash - NO RPC CALL
+     * Use this to build transactions before execution
+     */
+    getBlockhash(): {
+        blockhash: string;
+        lastValidBlockHeight: number;
+    } | null;
+    /**
+     * Get execution metrics
+     */
+    getMetrics(): ReturnType<HotPathMetrics['getStats']>;
+    private sleep;
+}
+/**
+ * Builds transactions using prefetched data - NO RPC CALLS
+ *
+ * Use this to construct transactions before hot path execution.
+ */
+declare class TransactionBuilder {
+    private executor;
+    constructor(executor: HotPathExecutor);
+    /**
+     * Build a transaction using prefetched blockhash - NO RPC
+     */
+    buildTransaction(payer: PublicKey, instructions: TransactionInstruction[], signers: any[], // Keypair[]
+    gasConfig?: GasFeeConfig): Promise<Transaction | null>;
+}
+/**
+ * Create a hot path executor with default configuration.
+ *
+ * Usage:
+ *   const executor = createHotPathExecutor(
+ *     connection,
+ *     [jitoClient, bloxrouteClient]
+ *   );
+ *   await executor.start();
+ *
+ *   // Prefetch required data
+ *   await executor.prefetchAccounts([tokenAccountPubkey]);
+ *
+ *   // Now ready for hot path execution
+ *   const result = await executor.execute('buy', txBytes);
+ */
+declare function createHotPathExecutor(connection: Connection, swqosClients?: SwqosClient[], config?: Partial<HotPathConfig>): HotPathExecutor;
+
+/**
+ * Execution: instruction preprocessing, cache prefetch, branch hints.
+ * 执行模块：指令预处理、缓存预取、分支提示。
+ *
+ * Based on sol-trade-sdk Rust implementation patterns.
+ */
+
+declare const BYTES_PER_ACCOUNT = 32;
+declare const MAX_INSTRUCTIONS_WARN = 64;
+/**
+ * Cache prefetching utilities.
+ * Call once on hot-path refs to reduce cache-miss latency.
+ */
+declare class Prefetch {
+    /**
+     * Prefetch instruction data into cache
+     * Accepts any instruction-shaped array (Rust: `Prefetch::instructions`).
+     */
+    static instructions(instructions: ReadonlyArray<unknown>): void;
+    /**
+     * Prefetch pubkey into cache
+     */
+    static pubkey(pubkey: Uint8Array): void;
+    /**
+     * Prefetch keypair data into cache
+     */
+    static keypair(keypair: unknown): void;
+}
+/**
+ * Handles instruction preprocessing and validation.
+ * Based on Rust's InstructionProcessor pattern.
+ */
+declare class InstructionProcessor {
+    /**
+     * Validate and prepare instructions for execution.
+     * Rust: `InstructionProcessor::preprocess` (empty check, prefetch, warn when count exceeds {@link MAX_INSTRUCTIONS_WARN}).
+     */
+    static preprocess(instructions: ReadonlyArray<unknown>): void;
+    /**
+     * Calculate total size for buffer allocation (web3 `keys` or internal `accounts`).
+     */
+    static calculateSize(instructions: ReadonlyArray<{
+        data: {
+            length: number;
+        };
+        keys?: readonly unknown[];
+        accounts?: readonly unknown[];
+    }>): number;
+}
+/**
+ * Trade direction and execution path utilities
+ */
+declare class ExecutionPath {
+    /**
+     * Rust `ExecutionPath::is_buy`: input mint is quote-side (SOL / WSOL / USD1 / USDC).
+     */
+    static isBuy(inputMint: PublicKey): boolean;
+    /**
+     * Select between fast and slow path
+     */
+    static select<T>(condition: boolean, fastPath: () => T, slowPath: () => T): T;
+}
+
+/**
+ * Poll multiple transaction signatures until one reaches confirmed/finalized without error.
+ * Rust: `swqos::common::poll_any_transaction_confirmation`.
+ */
+
+/**
+ * Map RPC `Commitment` to `getTransaction` `Finality` (web3: only `confirmed` | `finalized`).
+ * `processed` / unknown → `confirmed`.
+ */
+declare function commitmentToGetTxFinality(c: Commitment | undefined): Finality;
+interface ConfirmAnySignatureOptions {
+    commitment?: Commitment;
+    /**
+     * `getTransaction` lookup commitment (Rust: `CommitmentConfig::confirmed()`).
+     * Defaults from {@link commitmentToGetTxFinality}(`commitment`).
+     */
+    getTransactionCommitment?: Finality;
+    /** Default 15000 (Rust uses 15s). */
+    timeoutMs?: number;
+    pollIntervalMs?: number;
+    /**
+     * Rust waits until `poll_count >= 10` before `get_transaction_with_config` on the first landed signature.
+     * @default 10
+     */
+    pollsBeforeGetTransaction?: number;
+}
+/** Rust: log line patterns for user-facing failure hints. */
+declare function extractHintsFromLogs(logs: readonly string[] | null | undefined): string;
+/**
+ * Map `TransactionError` JSON (meta.err) to a numeric code; prefers Custom instruction code like Rust.
+ */
+declare function instructionErrorCodeFromMetaErr(err: unknown): {
+    code: number;
+    instructionIndex?: number;
+};
+/**
+ * Wait until any signature in `signatures` is confirmed successfully on-chain.
+ * Single-signature path uses `connection.confirmTransaction` (blockhash strategy when applicable).
+ */
+declare function confirmAnyTransactionSignature(connection: Connection, signatures: string[], options?: ConfirmAnySignatureOptions): Promise<string>;
+
+/**
+ * Bounded concurrency for async work (Rust SWQOS worker pool parity, best-effort in JS).
+ */
+declare function mapWithConcurrencyLimit<T, R>(items: readonly T[], concurrency: number, fn: (item: T, index: number) => Promise<R>): Promise<R[]>;
+
+/**
+ * Durable nonce helpers — aligned with Rust `src/common/nonce_cache.rs` `fetch_nonce_info`.
+ */
+
+/** Same shape as `DurableNonceInfo` in `index.ts` (used for `buy`/`sell` without circular imports). */
+interface FetchedDurableNonce {
+    nonceAccount: PublicKey;
+    authority: PublicKey;
+    /** Base58-encoded current nonce blockhash (32 bytes), for `recentBlockhash` / `nonceHash`. */
+    nonceHash: string;
+    /** Duplicate of `nonceHash` for parity with existing `DurableNonceInfo.recentBlockhash`. */
+    recentBlockhash: string;
+}
+/**
+ * Fetch durable nonce authority + current blockhash from a nonce account (RPC).
+ * Layout matches Rust: version (4) + authority_type (4) + authority (32) + blockhash (32) starting at offset 40.
+ */
+declare function fetchDurableNonceInfo(connection: Pick<Connection, 'getAccountInfo'>, nonceAccount: PublicKey): Promise<FetchedDurableNonce | null>;
+
+/**
+ * Secure key storage and management for Sol Trade SDK
+ *
+ * Implements secure memory handling for private keys with:
+ * - Memory encryption at rest
+ * - Secure zeroing after use
+ * - Context manager for automatic cleanup
+ */
+
+/**
+ * Error thrown when secure key operation fails
+ */
+declare class SecureKeyError extends Error {
+    constructor(message: string);
+}
+/**
+ * Error thrown when trying to access a cleared key
+ */
+declare class KeyNotAvailableError extends SecureKeyError {
+    constructor(message?: string);
+}
+/**
+ * Metadata about a stored key
+ */
+interface KeyMetadata {
+    pubkey: string;
+    createdAt: number;
+    lastAccessed?: number;
+    accessCount: number;
+}
+/**
+ * Secure storage for Solana private keys.
+ *
+ * Features:
+ * - Keys are encrypted in memory when not in use
+ * - Automatic secure zeroing of key material
+ * - Context manager support for temporary key access
+ */
+declare class SecureKeyStorage {
+    private encryptedKey;
+    private salt;
+    private pubkey;
+    private isUnlocked;
+    private unlockedKey;
+    private metadata;
+    private passwordProtected;
+    private constructor();
+    /**
+     * Create secure storage from a Keypair.
+     */
+    static fromKeypair(keypair: Keypair, password?: string): SecureKeyStorage;
+    /**
+     * Create secure storage from a seed.
+     */
+    static fromSeed(seed: Uint8Array, password?: string): SecureKeyStorage;
+    /**
+     * Create secure storage from a mnemonic phrase.
+     */
+    static fromMnemonic(mnemonic: string, password?: string): SecureKeyStorage;
+    private encryptWithPassword;
+    private decryptWithPassword;
+    private xorEncrypt;
+    /**
+     * Securely zero out sensitive data from memory
+     */
+    private static secureZero;
+    private secureZero;
+    /**
+     * Temporarily access the keypair.
+     * Key is automatically cleared after callback completes.
+     */
+    withKeypair<T>(callback: (keypair: Keypair) => Promise<T>, password?: string): Promise<T>;
+    /**
+     * Sign a message without exposing the keypair.
+     */
+    signMessage(message: Buffer | Uint8Array, password?: string): Promise<Buffer>;
+    /**
+     * Get the public key (safe to access)
+     */
+    getPublicKey(): string;
+    /**
+     * Check if storage requires password
+     */
+    get isPasswordProtected(): boolean;
+    /**
+     * Get key metadata
+     */
+    getMetadata(): KeyMetadata | null;
+    /**
+     * Permanently clear all key material
+     */
+    clear(): void;
+}
+/**
+ * Convenience function for quick signing
+ */
+declare function signWithKeypair(keypair: Keypair, message: Buffer | Uint8Array, clearAfter?: boolean): Promise<Buffer>;
+
+/**
+ * Input validators for Sol Trade SDK
+ *
+ * Provides secure input validation for:
+ * - RPC URLs
+ * - Program IDs
+ * - Amounts
+ * - Slippage values
+ */
+
+/**
+ * Error thrown when input validation fails
+ */
+declare class ValidationError extends Error {
+    constructor(message: string);
+}
+/**
+ * Known legitimate Solana program IDs
+ */
+declare const KNOWN_PROGRAM_IDS: Record<string, string[]>;
+/**
+ * Validate RPC URL format and security.
+ */
+declare function validateRpcUrl(url: string, allowHttp?: boolean): string;
+/**
+ * Validate a Solana program ID.
+ */
+declare function validateProgramId(programId: string, expectedProgram?: string): string;
+/**
+ * Validate an amount value.
+ */
+declare function validateAmount(amount: number | bigint, name?: string, allowZero?: boolean): bigint;
+/**
+ * Validate slippage in basis points.
+ */
+declare function validateSlippage(slippageBasisPoints: number): number;
+/**
+ * Validate a Solana public key.
+ */
+declare function validatePubkey(pubkey: string | PublicKey, name?: string): PublicKey;
+/**
+ * Validate a trading pair.
+ */
+declare function validateMintPair(inputMint: string, outputMint: string): void;
+/**
+ * Validate transaction size.
+ */
+declare function validateTransactionSize(transactionBytes: Buffer | Uint8Array, maxSize?: number): void;
+/**
+ * Validate a signature string.
+ */
+declare function validateSignature(signature: string): string;
+
+/**
+ * Address Lookup Table support for Solana transactions.
+ *
+ * This module provides functionality to fetch and use Address Lookup Tables (ALT)
+ * to reduce transaction size by storing frequently used addresses in a lookup table.
+ */
+
+/**
+ * Represents an address lookup table account.
+ */
+interface AddressLookupTableAccount {
+    key: PublicKey;
+    addresses: PublicKey[];
+}
+/**
+ * Fetch an address lookup table account from the blockchain.
+ *
+ * @param connection - Solana RPC connection
+ * @param lookupTableAddress - The address of the lookup table
+ * @param commitment - Commitment level for the query
+ * @returns AddressLookupTableAccount if found, null otherwise
+ */
+declare function fetchAddressLookupTableAccount(connection: Connection, lookupTableAddress: PublicKey, commitment?: 'processed' | 'confirmed' | 'finalized'): Promise<AddressLookupTableAccount | null>;
+/**
+ * Parse an address lookup table from account data.
+ *
+ * @param key - The lookup table public key
+ * @param accountInfo - The account info containing the lookup table data
+ * @returns AddressLookupTableAccount
+ */
+declare function parseAddressLookupTable(key: PublicKey, accountInfo: AccountInfo<Buffer>): AddressLookupTableAccount | null;
+/**
+ * Cache for address lookup tables to avoid repeated RPC calls.
+ */
+declare class AddressLookupTableCache {
+    private cache;
+    /**
+     * Get lookup table from cache or fetch from RPC.
+     *
+     * @param connection - Solana RPC connection
+     * @param lookupTableAddress - The lookup table address
+     * @returns AddressLookupTableAccount if found, null otherwise
+     */
+    getLookupTable(connection: Connection, lookupTableAddress: PublicKey): Promise<AddressLookupTableAccount | null>;
+    /**
+     * Get multiple lookup tables from cache or fetch from RPC.
+     *
+     * @param connection - Solana RPC connection
+     * @param lookupTableAddresses - Array of lookup table addresses
+     * @returns Array of AddressLookupTableAccount (null for not found)
+     */
+    getLookupTables(connection: Connection, lookupTableAddresses: PublicKey[]): Promise<(AddressLookupTableAccount | null)[]>;
+    /**
+     * Clear the cache.
+     */
+    clear(): void;
+    /**
+     * Remove a specific lookup table from cache.
+     *
+     * @param lookupTableAddress - The lookup table address to remove
+     */
+    remove(lookupTableAddress: PublicKey): void;
+    /**
+     * Get cache size.
+     */
+    get size(): number;
+}
+/**
+ * Default global cache instance.
+ */
+declare const addressLookupTableCache: AddressLookupTableCache;
+
+/**
+ * Trading factory and executor for Sol Trade SDK
+ *
+ * Provides factory methods for creating trade executors for different DEX protocols
+ */
+
+declare enum DexType$1 {
+    PumpFun = "PumpFun",
+    PumpSwap = "PumpSwap",
+    Bonk = "Bonk",
+    RaydiumCpmm = "RaydiumCpmm",
+    RaydiumAmmV4 = "RaydiumAmmV4",
+    MeteoraDammV2 = "MeteoraDammV2"
+}
+interface TradeResult$1 {
+    signature: string;
+    success: boolean;
+    error?: string;
+    confirmationTimeMs?: number;
+    submittedAt?: Date;
+    confirmedAt?: Date;
+    retries?: number;
+}
+interface BatchTradeResult {
+    results: TradeResult$1[];
+    totalTimeMs: number;
+    successCount: number;
+    failedCount: number;
+}
+interface TradeExecuteOptions {
+    waitConfirmation?: boolean;
+    maxRetries?: number;
+    retryDelayMs?: number;
+    parallelSubmit?: boolean;
+    timeoutMs?: number;
+    priority?: number;
+    skipPreflight?: boolean;
+}
+declare function defaultTradeExecuteOptions(): TradeExecuteOptions;
+interface ITradeExecutor {
+    executeBuy(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+    executeSell(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+}
+declare abstract class BaseExecutor implements ITradeExecutor {
+    abstract executeBuy(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+    abstract executeSell(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+    protected buildResult(signature: string, success: boolean, error?: string): TradeResult$1;
+}
+declare class PumpFunExecutor extends BaseExecutor {
+    executeBuy(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+    executeSell(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+}
+declare class PumpSwapExecutor extends BaseExecutor {
+    executeBuy(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+    executeSell(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+}
+declare class BonkExecutor extends BaseExecutor {
+    executeBuy(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+    executeSell(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+}
+declare class RaydiumCpmmExecutor extends BaseExecutor {
+    executeBuy(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+    executeSell(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+}
+declare class RaydiumAmmV4Executor extends BaseExecutor {
+    executeBuy(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+    executeSell(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+}
+declare class MeteoraDammV2Executor extends BaseExecutor {
+    executeBuy(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+    executeSell(_params: Record<string, unknown>, _opts?: TradeExecuteOptions): Promise<TradeResult$1>;
+}
+declare class TradeExecutorFactory {
+    private static executors;
+    /**
+     * Create a trade executor for the given DEX type
+     */
+    static createExecutor(dexType: DexType$1): ITradeExecutor;
+    /**
+     * Register a custom executor factory
+     */
+    static registerExecutor(dexType: DexType$1, factory: () => ITradeExecutor): void;
+    /**
+     * Get supported DEX types
+     */
+    static getSupportedDexTypes(): DexType$1[];
+}
+
+/**
+ * Sol Trade SDK - TypeScript SDK for Solana DEX trading
+ *
+ * A comprehensive SDK for seamless Solana DEX trading with support for
+ * PumpFun, PumpSwap, Bonk, Raydium CPMM, Raydium AMM V4, and Meteora DAMM V2.
+ */
+
+/**
+ * Supported DEX protocols
+ */
+declare enum DexType {
+    PumpFun = "PumpFun",
+    PumpSwap = "PumpSwap",
+    Bonk = "Bonk",
+    RaydiumCpmm = "RaydiumCpmm",
+    RaydiumAmmV4 = "RaydiumAmmV4",
+    MeteoraDammV2 = "MeteoraDammV2"
+}
+/**
+ * Type of token to trade
+ */
+declare enum TradeTokenType {
+    SOL = "SOL",
+    WSOL = "WSOL",
+    USD1 = "USD1",
+    USDC = "USDC"
+}
+/**
+ * Trade operation type
+ */
+declare enum TradeType {
+    Buy = "Buy",
+    Sell = "Sell"
+}
+/**
+ * SWQOS service regions
+ */
+declare enum SwqosRegion {
+    Frankfurt = "Frankfurt",
+    NewYork = "NewYork",
+    Amsterdam = "Amsterdam",
+    Dublin = "Dublin",
+    Tokyo = "Tokyo",
+    Singapore = "Singapore",
+    SLC = "SLC",
+    London = "London",
+    LosAngeles = "LosAngeles",
+    Default = "Default"
+}
+/**
+ * SWQOS service types
+ */
+declare enum SwqosType {
+    Default = "Default",
+    Jito = "Jito",
+    Bloxroute = "Bloxroute",
+    ZeroSlot = "ZeroSlot",
+    Temporal = "Temporal",
+    FlashBlock = "FlashBlock",
+    BlockRazor = "BlockRazor",
+    Node1 = "Node1",
+    Astralane = "Astralane",
+    NextBlock = "NextBlock",
+    Helius = "Helius",
+    Stellium = "Stellium",
+    Lightspeed = "Lightspeed",
+    Soyas = "Soyas",
+    Speedlanding = "Speedlanding",
+    Triton = "Triton",
+    QuickNode = "QuickNode",
+    Syndica = "Syndica",
+    Figment = "Figment",
+    Alchemy = "Alchemy"
+}
+declare enum SwqosTransport {
+    Http = "Http",
+    Grpc = "Grpc",
+    Quic = "Quic"
+}
+declare enum AstralaneTransport {
+    Binary = "Binary",
+    Plain = "Plain",
+    Quic = "Quic"
+}
+/**
+ * SWQOS service configuration
+ */
+interface SwqosConfig {
+    type: SwqosType;
+    region: SwqosRegion;
+    apiKey: string;
+    customUrl?: string;
+    mevProtection?: boolean;
+    transport?: SwqosTransport;
+    astralaneTransport?: AstralaneTransport;
+    swqosOnly?: boolean;
+}
+/**
+ * Gas fee strategy configuration
+ */
+interface GasFeeStrategyConfig {
+    buyPriorityFee: number;
+    sellPriorityFee: number;
+    buyComputeUnits: number;
+    sellComputeUnits: number;
+    buyTipLamports: number;
+    sellTipLamports: number;
+}
+/**
+ * Durable nonce information
+ *
+ * Populate via `fetchDurableNonceInfo` (Rust `fetch_nonce_info` parity) or manually.
+ */
+interface DurableNonceInfo {
+    nonceAccount: PublicKey;
+    authority: PublicKey;
+    nonceHash: string;
+    recentBlockhash: string;
+}
+/**
+ * Buy trade parameters
+ */
+interface TradeBuyParams {
+    dexType: DexType;
+    inputTokenType: TradeTokenType;
+    mint: PublicKey;
+    inputTokenAmount: number;
+    slippageBasisPoints?: number;
+    recentBlockhash?: string;
+    extensionParams: DexParamEnum;
+    addressLookupTableAccount?: AddressLookupTableAccount$1;
+    waitTxConfirmed?: boolean;
+    createInputTokenAta?: boolean;
+    closeInputTokenAta?: boolean;
+    createMintAta?: boolean;
+    durableNonce?: DurableNonceInfo;
+    fixedOutputTokenAmount?: number;
+    gasFeeStrategy?: GasFeeStrategyConfig;
+    simulate?: boolean;
+    useExactSolAmount?: boolean;
+    grpcRecvUs?: number;
+}
+/**
+ * Sell trade parameters
+ */
+interface TradeSellParams {
+    dexType: DexType;
+    outputTokenType: TradeTokenType;
+    mint: PublicKey;
+    inputTokenAmount: number;
+    slippageBasisPoints?: number;
+    recentBlockhash?: string;
+    withTip?: boolean;
+    extensionParams: DexParamEnum;
+    addressLookupTableAccount?: AddressLookupTableAccount$1;
+    waitTxConfirmed?: boolean;
+    createOutputTokenAta?: boolean;
+    closeOutputTokenAta?: boolean;
+    closeMintTokenAta?: boolean;
+    durableNonce?: DurableNonceInfo;
+    fixedOutputTokenAmount?: number;
+    gasFeeStrategy?: GasFeeStrategyConfig;
+    simulate?: boolean;
+    grpcRecvUs?: number;
+}
+/**
+ * Trade execution result
+ */
+interface TradeResult {
+    success: boolean;
+    signatures: string[];
+    error?: TradeError;
+    timings: SwqosTiming[];
+    /**
+     * Set when `simulate: true` on buy/sell — Rust `simulate_transaction` (`units_consumed`, `logs`).
+     */
+    simulation?: {
+        unitsConsumed?: number;
+        logs?: string[] | null;
+    };
+}
+/**
+ * SWQOS timing information
+ */
+interface SwqosTiming {
+    swqosType: SwqosType;
+    duration: number;
+    /** Present when `TradeConfig.gasStrategy` expands multiple Rust `GasFeeStrategyType` rows. */
+    gasFeeStrategyType?: GasFeeStrategyType;
+}
+
+/**
+ * Bonding curve account state
+ */
+interface BondingCurveAccount {
+    discriminator: number;
+    account: PublicKey;
+    virtualTokenReserves: number;
+    virtualSolReserves: number;
+    realTokenReserves: number;
+    realSolReserves: number;
+    tokenTotalSupply: number;
+    complete: boolean;
+    creator: PublicKey;
+    isMayhemMode: boolean;
+    isCashbackCoin: boolean;
+}
+/**
+ * PumpFun protocol parameters
+ */
+interface PumpFunParams {
+    bondingCurve: BondingCurveAccount;
+    associatedBondingCurve: PublicKey;
+    creatorVault: PublicKey;
+    tokenProgram: PublicKey;
+    observedTradeCreator?: PublicKey;
+    feeSharingCreatorVaultIfActive?: PublicKey;
+    closeTokenAccountWhenSell?: boolean;
+    /** Parser/gRPC fee recipient; omit or `PublicKey.default` for SDK random pool (Rust parity). */
+    feeRecipient?: PublicKey;
+    /** PumpFun V2 quote mint; omit or default pubkey for WSOL. */
+    quoteMint?: PublicKey;
+    /** Per-token V2 ix toggle; global `TradeConfig.usePumpfunV2` also enables it. */
+    useV2Ix?: boolean;
+}
+/**
+ * PumpSwap protocol parameters
+ */
+interface PumpSwapParams {
+    pool: PublicKey;
+    baseMint: PublicKey;
+    quoteMint: PublicKey;
+    poolBaseTokenAccount: PublicKey;
+    poolQuoteTokenAccount: PublicKey;
+    poolBaseTokenReserves: number;
+    poolQuoteTokenReserves: number;
+    coinCreatorVaultAta: PublicKey;
+    coinCreatorVaultAuthority: PublicKey;
+    baseTokenProgram: PublicKey;
+    quoteTokenProgram: PublicKey;
+    isMayhemMode: boolean;
+    isCashbackCoin: boolean;
+}
+/**
+ * Bonk protocol parameters
+ */
+interface BonkParams {
+    virtualBase: bigint;
+    virtualQuote: bigint;
+    realBase: bigint;
+    realQuote: bigint;
+    poolState: PublicKey;
+    baseVault: PublicKey;
+    quoteVault: PublicKey;
+    mintTokenProgram: PublicKey;
+    platformConfig: PublicKey;
+    platformAssociatedAccount: PublicKey;
+    creatorAssociatedAccount: PublicKey;
+    globalConfig: PublicKey;
+}
+/**
+ * Raydium CPMM protocol parameters
+ */
+interface RaydiumCpmmParams {
+    poolState: PublicKey;
+    ammConfig: PublicKey;
+    baseMint: PublicKey;
+    quoteMint: PublicKey;
+    baseReserve: number;
+    quoteReserve: number;
+    baseVault: PublicKey;
+    quoteVault: PublicKey;
+    baseTokenProgram: PublicKey;
+    quoteTokenProgram: PublicKey;
+    observationState: PublicKey;
+}
+/**
+ * Raydium AMM V4 protocol parameters
+ */
+interface RaydiumAmmV4Params {
+    amm: PublicKey;
+    coinMint: PublicKey;
+    pcMint: PublicKey;
+    tokenCoin: PublicKey;
+    tokenPc: PublicKey;
+    coinReserve: number;
+    pcReserve: number;
+}
+/**
+ * Meteora DAMM V2 protocol parameters
+ */
+interface MeteoraDammV2Params {
+    pool: PublicKey;
+    tokenAVault: PublicKey;
+    tokenBVault: PublicKey;
+    tokenAMint: PublicKey;
+    tokenBMint: PublicKey;
+    tokenAProgram: PublicKey;
+    tokenBProgram: PublicKey;
+}
+/**
+ * Union type for DEX parameters
+ */
+type DexParamEnum = {
+    type: 'PumpFun';
+    params: PumpFunParams;
+} | {
+    type: 'PumpSwap';
+    params: PumpSwapParams;
+} | {
+    type: 'Bonk';
+    params: BonkParams;
+} | {
+    type: 'RaydiumCpmm';
+    params: RaydiumCpmmParams;
+} | {
+    type: 'RaydiumAmmV4';
+    params: RaydiumAmmV4Params;
+} | {
+    type: 'MeteoraDammV2';
+    params: MeteoraDammV2Params;
+};
+/**
+ * Trading configuration
+ */
+interface TradeConfig {
+    rpcUrl: string;
+    swqosConfigs: SwqosConfig[];
+    commitment?: Commitment;
+    logEnabled?: boolean;
+    checkMinTip?: boolean;
+    mevProtection?: boolean;
+    /** Default gas/CU settings when trade params omit `gasFeeStrategy`. */
+    gasFeeStrategy?: GasFeeStrategyConfig;
+    /**
+     * Per-SWQOS gas table (Rust `GasFeeStrategy`). Used when neither trade nor `gasFeeStrategy` flat config is set.
+     * Lookup uses the first SWQOS entry after `withTip` / `checkMinTip` filtering.
+     */
+    gasStrategy?: GasFeeStrategy;
+    /** Reserved for Rust parity (seed-optimized ATA); instruction builders may ignore if not wired. */
+    useSeedOptimize?: boolean;
+    /** Use PumpFun V2 ix layout by default (`buy_v2` / `sell_v2` / quote mint support). */
+    usePumpfunV2?: boolean;
+    /** Prefer assigning SWQOS submit threads from the end of the CPU core list. */
+    swqosCoresFromEnd?: boolean;
+    /** If true, best-effort background WSOL ATA creation after connect (Rust `create_wsol_ata_on_startup`). */
+    createWsolAtaOnStartup?: boolean;
+    /**
+     * Rust `MiddlewareManager`: `process_protocol_instructions` before gas/tip wiring;
+     * `process_full_instructions` after nonce + tip + compute budget + protocol (see `transaction_builder.rs`).
+     */
+    middlewareManager?: MiddlewareManager;
+    /**
+     * Cap concurrent SWQOS `sendTransaction` calls when multiple gas/SWQOS tasks run.
+     * Rust uses a bounded worker pool (`max_sender_concurrency`); set this to approximate that (e.g. 8–18).
+     * Omit or set ≥ task count to keep previous behavior (all tasks parallel).
+     */
+    maxSwqosSubmitConcurrency?: number;
+}
+/**
+ * Builder for TradeConfig - makes all options discoverable via IDE autocomplete.
+ *
+ * @example
+ * const config = TradeConfigBuilder.create(rpcUrl)
+ *   .swqosConfigs([{ type: SwqosType.Jito, apiKey: 'your-key' }])
+ *   // .mevProtection(true)   // Enable MEV protection (BlockRazor: sandwichMitigation, Astralane: port 9000)
+ *   .build();
+ */
+declare class TradeConfigBuilder {
+    private _rpcUrl;
+    private _swqosConfigs;
+    private _commitment?;
+    private _logEnabled;
+    private _checkMinTip;
+    private _mevProtection;
+    private _useSeedOptimize;
+    private _usePumpfunV2;
+    private _swqosCoresFromEnd;
+    private _createWsolAtaOnStartup;
+    private _gasFeeStrategy?;
+    private _gasStrategy?;
+    private _middlewareManager?;
+    private _maxSwqosSubmitConcurrency?;
+    private constructor();
+    static create(rpcUrl: string): TradeConfigBuilder;
+    swqosConfigs(configs: SwqosConfig[]): this;
+    commitment(commitment: Commitment): this;
+    logEnabled(enabled: boolean): this;
+    checkMinTip(check: boolean): this;
+    /**
+     * Enable MEV protection (default: false).
+     * When enabled:
+     * - BlockRazor uses mode=sandwichMitigation
+     * - Astralane uses port 9000 MEV-protected QUIC endpoint
+     */
+    mevProtection(enabled: boolean): this;
+    useSeedOptimize(enabled: boolean): this;
+    usePumpfunV2(enabled: boolean): this;
+    swqosCoresFromEnd(enabled: boolean): this;
+    createWsolAtaOnStartup(enabled: boolean): this;
+    gasFeeStrategy(config: GasFeeStrategyConfig): this;
+    gasStrategy(strategy: GasFeeStrategy): this;
+    /** Rust `SolanaTrade::with_middleware_manager` parity. */
+    middlewareManager(manager: MiddlewareManager): this;
+    /**
+     * Limit parallel SWQOS submits (Rust `max_sender_concurrency` / worker pool).
+     */
+    maxSwqosSubmitConcurrency(limit: number | undefined): this;
+    build(): TradeConfig;
+}
+declare function recommendedSenderThreadCoreIndices(swqosCount: number, availableCores?: number, fromEnd?: boolean): number[];
+/**
+ * Middleware context
+ */
+interface MiddlewareContext {
+    tradeType: TradeType;
+    inputMint: PublicKey;
+    outputMint: PublicKey;
+    inputAmount: number;
+    payer: PublicKey;
+    additionalData?: Record<string, unknown>;
+}
+/**
+ * Middleware interface
+ */
+interface Middleware {
+    process(instructions: TransactionInstruction[], context: MiddlewareContext): Promise<TransactionInstruction[]>;
+    name: string;
+}
+/**
+ * 按 mint 查找池地址（与 Rust `find_pool_by_mint` 一致：当前仅 PumpSwap）。
+ */
+declare function findPoolByMint(connection: Connection, mint: PublicKey, dexType: DexType): Promise<PublicKey>;
+/** Rust `executor::simulate_transaction` / `RpcSimulateTransactionConfig` (processed, inner ix, no sig verify). */
+declare const RUST_PARITY_SIMULATE_CONFIG: SimulateTransactionConfig;
+/**
+ * Main trading client for Solana DEX operations（指令构建与 Rust SDK 对齐，经 `instruction/*` 实现）
+ */
+declare class TradingClient {
+    private payer;
+    private connection;
+    private _config;
+    private middlewares;
+    private _logEnabled;
+    constructor(payer: Keypair, config: TradeConfig);
+    /** Get the current configuration */
+    get config(): TradeConfig;
+    /** Check if logging is enabled */
+    get isLogEnabled(): boolean;
+    /**
+     * Get the underlying connection
+     */
+    getConnection(): Connection;
+    /**
+     * Get the payer public key
+     */
+    getPayer(): PublicKey;
+    private rpcCommitment;
+    /**
+     * Add middleware to the chain
+     */
+    addMiddleware(middleware: Middleware): this;
+    /**
+     * Execute a buy order
+     */
+    buy(params: TradeBuyParams): Promise<TradeResult>;
+    /**
+     * Execute a sell order
+     */
+    sell(params: TradeSellParams): Promise<TradeResult>;
+    /**
+     * Execute a sell order for a percentage of tokens
+     */
+    sellByPercent(params: TradeSellParams, totalAmount: number, percent: number): Promise<TradeResult>;
+    /**
+     * Get latest blockhash
+     */
+    getLatestBlockhash(): Promise<BlockhashWithExpiryBlockHeight>;
+    /**
+     * Wrap SOL to WSOL
+     */
+    wrapSolToWsol(amount: number): Promise<string>;
+    /**
+     * Close WSOL account and unwrap to SOL
+     */
+    closeWsol(): Promise<string>;
+    /**
+     * Claim PumpFun bonding-curve cashback (SOL → wallet).
+     */
+    claimCashbackPumpfun(): Promise<string>;
+    /**
+     * Claim PumpSwap AMM cashback（会先走 WSOL ATA idempotent 创建，与 Rust 一致）。
+     */
+    claimCashbackPumpswap(): Promise<string>;
+    private sendSingleInstruction;
+    private sendInstructions;
+    private buildBuyInstructions;
+    private buildSellInstructions;
+    private getInputMint;
+    private getOutputMint;
+    private processMiddlewares;
+    private executeTransaction;
+}
+/**
+ * Create a new gas fee strategy with defaults
+ */
+declare function createGasFeeStrategy(): GasFeeStrategy;
+/**
+ * Create a new trade config (shorthand for {@link TradeConfig} / {@link TradeConfigBuilder}).
+ */
+declare function createTradeConfig(rpcUrl: string, swqosConfigs?: SwqosConfig[], options?: Partial<Omit<TradeConfig, 'rpcUrl' | 'swqosConfigs'>>): TradeConfig;
+
+export { AMM_INFO_SIZE, ASSOCIATED_TOKEN_PROGRAM, type AccountState, type AddressLookupTableAccount, AddressLookupTableCache, AstralaneTransport, BONK_AUTHORITY, BONK_BUY_EXACT_IN_DISCRIMINATOR, BONK_EVENT_AUTHORITY, BONK_GLOBAL_CONFIG, BONK_PLATFORM_FEE_RATE, BONK_POOL_SEED, BONK_POOL_STATE_SIZE, BONK_POOL_VAULT_SEED, BONK_PROGRAM, BONK_PROGRAM_ID, BONK_PROTOCOL_FEE_RATE, BONK_SELL_EXACT_IN_DISCRIMINATOR, BONK_SHARE_FEE_RATE, BONK_USD1_GLOBAL_CONFIG, BYTES_PER_ACCOUNT, BaseExecutor, type BatchTradeResult, type BondingCurveAccount, type BonkBuildBuyParams, type BonkBuildSellParams, BonkExecutor, type BonkParams, type BonkPoolState, type BonkVestingSchedule, type BuildBuyParams, type BuildMeteoraDammV2BuyInstructionsParams, type BuildMeteoraDammV2SellInstructionsParams, type BuildRaydiumAmmV4BuyInstructionsParams, type BuildRaydiumAmmV4SellInstructionsParams, type BuildRaydiumCpmmBuyInstructionsParams, type BuildRaydiumCpmmSellInstructionsParams, type BuildSellParams, CONSTANTS, type ConfirmAnySignatureOptions, ContextExpiredError, DEFAULT_COMPUTE_UNITS, DEFAULT_PRIORITY_FEE, DEFAULT_SLIPPAGE, DEFAULT_TIP_LAMPORTS, type DexParamEnum, DexType, type DurableNonceInfo, type ExecuteOptions, type ExecuteResult, ExecutionPath, type FetchedDurableNonce, FilterMiddleware, type GasFeeConfig, GasFeeStrategy, type GasFeeStrategyConfig, GasFeeStrategyType, type GasFeeStrategyValue, type HotPathConfig, HotPathError, HotPathExecutor, HotPathMetrics, HotPathState, type ITradeExecutor, type InstructionMiddleware, InstructionProcessor, KNOWN_PROGRAM_IDS, type KeyMetadata, KeyNotAvailableError, LoggingMiddleware, MAX_INSTRUCTIONS_WARN, METEORA_DAMM_V2_AUTHORITY, METEORA_DAMM_V2_EVENT_AUTHORITY_SEED, METEORA_DAMM_V2_PROGRAM, METEORA_DAMM_V2_PROGRAM_ID, METEORA_DAMM_V2_SWAP_DISCRIMINATOR, METEORA_POOL_SIZE, MeteoraDammV2Executor, type MeteoraDammV2Params, type MeteoraDammV2Pool, MetricsMiddleware, type Middleware, type MiddlewareContext, MiddlewareManager, MissingAccountError, POOL_SIZE, PUMPFUN_BONDING_CURVE_SEED, PUMPFUN_BONDING_CURVE_V2_SEED, PUMPFUN_BUYBACK_FEE_RECIPIENTS, PUMPFUN_BUY_DISCRIMINATOR, PUMPFUN_BUY_EXACT_QUOTE_IN_V2_DISCRIMINATOR, PUMPFUN_BUY_EXACT_SOL_IN_DISCRIMINATOR, PUMPFUN_BUY_V2_DISCRIMINATOR, PUMPFUN_CLAIM_CASHBACK_DISCRIMINATOR, PUMPFUN_CREATOR_VAULT_SEED, PUMPFUN_DISCRIMINATORS, PUMPFUN_EVENT_AUTHORITY, PUMPFUN_FEE_CONFIG, PUMPFUN_FEE_PROGRAM, PUMPFUN_FEE_RECIPIENT, PUMPFUN_GLOBAL_ACCOUNT, PUMPFUN_GLOBAL_VOLUME_ACCUMULATOR, PUMPFUN_MAYHEM_FEE_RECIPIENTS, PUMPFUN_PROGRAM, PUMPFUN_PROGRAM_ID, PUMPFUN_PROTOCOL_EXTRA_FEE_RECIPIENTS, PUMPFUN_SELL_DISCRIMINATOR, PUMPFUN_SELL_V2_DISCRIMINATOR, PUMPFUN_SHARING_CONFIG_SEED, PUMPFUN_STANDARD_FEE_RECIPIENTS, PUMPFUN_USER_VOLUME_ACCUMULATOR_SEED, PUMPSWAP_BUY_DISCRIMINATOR, PUMPSWAP_BUY_EXACT_QUOTE_IN_DISCRIMINATOR, PUMPSWAP_CLAIM_CASHBACK_DISCRIMINATOR, PUMPSWAP_DEFAULT_COIN_CREATOR_VAULT_AUTHORITY, PUMPSWAP_DISCRIMINATORS, PUMPSWAP_EVENT_AUTHORITY, PUMPSWAP_FEE_CONFIG, PUMPSWAP_FEE_PROGRAM, PUMPSWAP_FEE_RECIPIENT, PUMPSWAP_GLOBAL_ACCOUNT, PUMPSWAP_GLOBAL_VOLUME_ACCUMULATOR, PUMPSWAP_MAYHEM_FEE_RECIPIENTS, PUMPSWAP_PROGRAM, PUMPSWAP_PROGRAM_ID, PUMPSWAP_PROTOCOL_EXTRA_FEE_RECIPIENTS, PUMPSWAP_PUMP_PROGRAM_ID, PUMPSWAP_SELL_DISCRIMINATOR, type PoolState, Prefetch, type PrefetchedData, type PumpFunBondingCurve, type PumpFunBuildBuyParams, type PumpFunBuildSellParams, PumpFunExecutor, type PumpFunParams, PumpSwapExecutor, type PumpSwapParams, type PumpSwapPool, RAYDIUM_AMM_V4_AUTHORITY, RAYDIUM_AMM_V4_POOL_SEED, RAYDIUM_AMM_V4_PROGRAM, RAYDIUM_AMM_V4_PROGRAM_ID, RAYDIUM_AMM_V4_SWAP_BASE_IN_DISCRIMINATOR, RAYDIUM_AMM_V4_SWAP_BASE_OUT_DISCRIMINATOR, RAYDIUM_AMM_V4_SWAP_FEE_DENOMINATOR, RAYDIUM_AMM_V4_SWAP_FEE_NUMERATOR, RAYDIUM_AMM_V4_TRADE_FEE_DENOMINATOR, RAYDIUM_AMM_V4_TRADE_FEE_NUMERATOR, RAYDIUM_CPMM_AUTHORITY, RAYDIUM_CPMM_CREATOR_FEE_RATE, RAYDIUM_CPMM_FEE_RATE_DENOMINATOR_VALUE, RAYDIUM_CPMM_FUND_FEE_RATE, RAYDIUM_CPMM_OBSERVATION_STATE_SEED, RAYDIUM_CPMM_POOL_SEED, RAYDIUM_CPMM_POOL_STATE_SIZE, RAYDIUM_CPMM_POOL_VAULT_SEED, RAYDIUM_CPMM_PROGRAM, RAYDIUM_CPMM_PROGRAM_ID, RAYDIUM_CPMM_PROTOCOL_FEE_RATE, RAYDIUM_CPMM_SWAP_BASE_IN_DISCRIMINATOR, RAYDIUM_CPMM_SWAP_BASE_OUT_DISCRIMINATOR, RAYDIUM_CPMM_TRADE_FEE_RATE, RENT, RUST_PARITY_SIMULATE_CONFIG, type RaydiumAmmFees, type RaydiumAmmInfo, type RaydiumAmmOutputData, RaydiumAmmV4Executor, type RaydiumAmmV4Params, type RaydiumCPMMpoolState, RaydiumCpmmExecutor, type RaydiumCpmmParams, SDK_FEE_RECIPIENT, SDK_MAYHEM_FEE_RECIPIENTS, SOL_TOKEN_ACCOUNT, SWQOS_ENDPOINTS, SYSTEM_PROGRAM, SecureKeyError, SecureKeyStorage, StaleBlockhashError, type SwqosConfig, SwqosRegion, type SwqosTiming, SwqosTransport, SwqosType, TOKEN_PROGRAM, TOKEN_PROGRAM_2022, TimerMiddleware, type TradeBuyParams, type TradeConfig, TradeConfigBuilder, TradeError, type TradeExecuteOptions, TradeExecutorFactory, type TradeResult, type TradeSellParams, TradeTokenType, TradeType, TradingClient, TradingContext, TransactionBuilder, USD1_MINT, USD1_TOKEN_ACCOUNT, USDC_MINT, USDC_TOKEN_ACCOUNT, ValidationError, ValidationMiddleware, WSOL_MINT, WSOL_TOKEN_ACCOUNT, addressLookupTableCache, buildBonkBuyInstructions, buildBonkSellInstructions, buildBuyInstructions, buildClaimCashbackInstruction, buildMeteoraDammV2BuyInstructions, buildMeteoraDammV2SellInstructions, buildPumpFunBuyInstructions, buildPumpFunBuyV2Instructions, buildPumpFunClaimCashbackInstruction, buildPumpFunSellInstructions, buildPumpFunSellV2Instructions, buildRaydiumAmmV4BuyInstructions, buildRaydiumAmmV4SellInstructions, buildRaydiumCpmmBuyInstructions, buildRaydiumCpmmSellInstructions, buildSellInstructions, calculatePriceImpact, calculateWithSlippageBuy, calculateWithSlippageSell, closeWsol, commitmentToGetTxFinality, computeRaydiumAmmV4SwapAmount, computeRaydiumCpmmSwapAmount, confirmAnyTransactionSignature, createAssociatedTokenAccountIdempotent, createGasFeeStrategy, createHotPathExecutor, createTradeConfig, decodeAmmInfo, decodeBonkPoolState, decodeMeteoraPool, decodePool, decodeRaydiumCPMMpoolState, defaultExecuteOptions, defaultHotPathConfig, defaultTradeExecuteOptions, extractHintsFromLogs, fetchAddressLookupTableAccount, fetchAmmInfo, fetchBondingCurveAccount, fetchBonkPoolState, fetchDurableNonceInfo, fetchMeteoraPool, fetchPool, fetchRaydiumCPMMpoolState, findByBaseMint, findByMint, findByQuoteMint, findPoolByMint, formatPublicKey, getAssociatedTokenAddress, getBondingCurvePda, getBondingCurveV2Pda, getBonkCreatorAssociatedAccount, getBonkPlatformAssociatedAccount, getBonkPoolPDA, getBonkPoolPda, getBonkVaultPDA, getBonkVaultPda, getBuyPrice, getBuyTokenAmountFromSolAmount, getCanonicalPoolPDA, getCoinCreatorVaultAta, getCoinCreatorVaultAuthority, getCreator, getCreatorVaultPda, getFeeConfigPDA, getFeeRecipientAta, getGlobalVolumeAccumulatorPDA, getMayhemFeeRecipientRandom, getMeteoraDammV2EventAuthorityPda, getPoolV2PDA, getPumpFunBuybackFeeRecipientRandom, getPumpFunFeeSharingConfigPda, getPumpFunProtocolExtraFeeRecipientRandom, getPumpFunUserVolumeAccumulatorPda, getPumpPoolAuthorityPDA, getPumpSwapProtocolExtraFeeRecipientRandom, getRandomMayhemFeeRecipient, getRaydiumCPMMobservationStatePDA, getRaydiumCPMMpoolPDA, getRaydiumCPMMpoolTokenBalances, getRaydiumCPMMvaultPDA, getRaydiumCpmmObservationStatePda, getRaydiumCpmmPoolPda, getRaydiumCpmmVaultPda, getSellSolAmountFromTokenAmount, getStandardFeeRecipientRandom, getTokenBalances, getUserVolumeAccumulatorPDA, getUserVolumeAccumulatorQuoteAta, getUserVolumeAccumulatorWsolAta, handleWsol, instructionErrorCodeFromMetaErr, isValidPublicKey, lamportsToSol, mapWithConcurrencyLimit, nowMicroseconds, parseAddressLookupTable, pumpFunFeeRecipientMeta, recommendedSenderThreadCoreIndices, retryWithBackoff, signWithKeypair, sleep, solToLamports, validateAmount, validateMintPair, validateProgramId, validatePubkey, validateRpcUrl, validateSignature, validateSlippage, validateTransactionSize, withAllBuiltinMiddlewares, withStandardMiddlewares };