sol-trade-sdk 0.1.0 → 0.1.2

package/dist/index-hZh5hrGj.d.mts

@@ -0,0 +1,3089 @@
+import { TransactionInstruction, PublicKey, Keypair, Connection, Transaction, Commitment, Finality, AccountInfo, SimulateTransactionConfig, AddressLookupTableAccount as AddressLookupTableAccount$1, BlockhashWithExpiryBlockHeight } from '@solana/web3.js';
+import './index-1BK_FXsW.mjs';
+
+/**
+ * Gas Fee Strategy for Sol Trade SDK
+ */
+declare enum TradeType$2 {
+    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$2, cuLimit: number, lowCuPrice: number, highCuPrice: number, lowTip: number, highTip: number): void;
+    /**
+     * Set a specific gas fee strategy
+     */
+    set(swqosType: SwqosType$1, tradeType: TradeType$2, strategyType: GasFeeStrategyType, cuLimit: number, cuPrice: number, tip: number): void;
+    /**
+     * Get a specific gas fee strategy
+     */
+    get(swqosType: SwqosType$1, tradeType: TradeType$2, strategyType: GasFeeStrategyType): GasFeeStrategyValue | undefined;
+    /**
+     * Delete a specific gas fee strategy
+     */
+    delete(swqosType: SwqosType$1, tradeType: TradeType$2, strategyType: GasFeeStrategyType): void;
+    /**
+     * Delete all strategies for a SWQOS type and trade type
+     */
+    deleteAll(swqosType: SwqosType$1, tradeType: TradeType$2): void;
+    /**
+     * Get all strategies for a trade type
+     */
+    getStrategies(tradeType: TradeType$2): 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$2 {
+    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;
+    /** Layout selector: default/Solscan SOL sentinel keeps legacy SOL; WSOL/USDC selects V2. */
+    quoteMint?: PublicKey;
+}
+interface PumpFunBuildBuyParams {
+    payer: Keypair | PublicKey;
+    inputMint?: PublicKey;
+    outputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createOutputMintAta?: boolean;
+    createInputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: PumpFunParams$2;
+    useExactSolAmount?: boolean;
+}
+interface PumpFunBuildSellParams {
+    payer: Keypair | PublicKey;
+    inputMint: PublicKey;
+    outputMint?: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: PumpFunParams$2;
+}
+/**
+ * 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$2 {
+    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$2;
+    createInputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    createOutputMintAta?: boolean;
+    useExactQuoteAmount?: boolean;
+    fixedOutputAmount?: bigint;
+}
+interface BuildSellParams {
+    payer: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints: bigint;
+    protocolParams: PumpSwapParams$2;
+    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$2 {
+    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$2;
+}
+interface BonkBuildSellParams {
+    payer: Keypair | PublicKey;
+    inputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createOutputMintAta?: boolean;
+    closeOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: BonkParams$2;
+}
+/**
+ * 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$2 {
+    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$2;
+}
+interface BuildRaydiumCpmmSellInstructionsParams {
+    payer: Keypair | PublicKey;
+    inputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createOutputMintAta?: boolean;
+    closeOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: RaydiumCpmmParams$2;
+}
+/**
+ * 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$2 {
+    amm: PublicKey;
+    coinMint: PublicKey;
+    pcMint: PublicKey;
+    tokenCoin: PublicKey;
+    tokenPc: PublicKey;
+    ammOpenOrders: PublicKey;
+    ammTargetOrders: PublicKey;
+    serumProgram: PublicKey;
+    serumMarket: PublicKey;
+    serumBids: PublicKey;
+    serumAsks: PublicKey;
+    serumEventQueue: PublicKey;
+    serumCoinVaultAccount: PublicKey;
+    serumPcVaultAccount: PublicKey;
+    serumVaultSigner: 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$2;
+}
+interface BuildRaydiumAmmV4SellInstructionsParams {
+    payer: Keypair | PublicKey;
+    inputMint: PublicKey;
+    outputMint?: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createOutputMintAta?: boolean;
+    closeOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: RaydiumAmmV4Params$2;
+}
+/**
+ * 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;
+}
+interface RaydiumMarketState {
+    vaultSignerNonce: bigint;
+    serumCoinVaultAccount: PublicKey;
+    serumPcVaultAccount: PublicKey;
+    serumEventQueue: PublicKey;
+    serumBids: PublicKey;
+    serumAsks: PublicKey;
+}
+declare const MARKET_STATE_SIZE = 388;
+/**
+ * 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;
+declare function decodeMarketState(data: Buffer): RaydiumMarketState | null;
+declare function deriveSerumVaultSigner(serumProgram: PublicKey, serumMarket: PublicKey, vaultSignerNonce: bigint): PublicKey;
+/**
+ * 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>;
+declare function fetchMarketState(connection: {
+    getAccountInfo: (pubkey: PublicKey) => Promise<{
+        value?: {
+            data: Buffer;
+        };
+    }>;
+}, market: PublicKey): Promise<RaydiumMarketState | 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_SWAP2_DISCRIMINATOR: Buffer;
+declare const METEORA_DAMM_V2_SWAP_MODE_PARTIAL_FILL = 1;
+declare const METEORA_DAMM_V2_EVENT_AUTHORITY_SEED: Buffer<ArrayBuffer>;
+/**
+ * Derive the event authority PDA
+ */
+declare function getMeteoraDammV2EventAuthorityPda(): PublicKey;
+interface MeteoraDammV2Params$2 {
+    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$2;
+}
+interface BuildMeteoraDammV2SellInstructionsParams {
+    payer: Keypair | PublicKey;
+    inputMint: PublicKey;
+    outputMint: PublicKey;
+    inputAmount: bigint;
+    slippageBasisPoints?: bigint;
+    fixedOutputAmount?: bigint;
+    createOutputMintAta?: boolean;
+    closeOutputMintAta?: boolean;
+    closeInputMintAta?: boolean;
+    protocolParams: MeteoraDammV2Params$2;
+}
+/**
+ * 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.
+ */
+
+declare function randomChoice<T>(arr: T[]): T;
+declare const MIN_TIP_JITO = 0.00001;
+declare const MIN_TIP_BLOXROUTE = 0.0001;
+declare const MIN_TIP_ZERO_SLOT = 0.0001;
+declare const MIN_TIP_TEMPORAL = 0.0001;
+declare const MIN_TIP_FLASH_BLOCK = 0.0001;
+declare const MIN_TIP_BLOCK_RAZOR = 0.0001;
+declare const MIN_TIP_NODE1 = 0.0001;
+declare const MIN_TIP_ASTRALANE = 0.00001;
+declare const MIN_TIP_HELIUS = 0.000005;
+declare const MIN_TIP_HELIUS_NORMAL = 0.0002;
+declare const MIN_TIP_STELLIUM = 0.0001;
+declare const MIN_TIP_LIGHTSPEED = 0.0001;
+declare const MIN_TIP_NEXT_BLOCK = 0.001;
+declare const MIN_TIP_SOYAS = 0.001;
+declare const MIN_TIP_SPEEDLANDING = 0.001;
+declare const MIN_TIP_DEFAULT = 0;
+declare const JITO_ENDPOINTS: Record<SwqosRegion, string>;
+declare const BLOXROUTE_ENDPOINTS: Record<SwqosRegion, string>;
+declare const ZERO_SLOT_ENDPOINTS: Record<SwqosRegion, string>;
+declare const TEMPORAL_ENDPOINTS: Record<SwqosRegion, string>;
+declare const FLASH_BLOCK_ENDPOINTS: Record<SwqosRegion, string>;
+declare const HELIUS_ENDPOINTS: Record<SwqosRegion, string>;
+declare const NODE1_ENDPOINTS: Record<SwqosRegion, string>;
+declare const BLOCK_RAZOR_ENDPOINTS: Record<SwqosRegion, string>;
+declare const ASTRALANE_ENDPOINTS: Record<SwqosRegion, string>;
+declare const ASTRALANE_QUIC_HOSTS: Record<SwqosRegion, string>;
+declare const STELLIUM_ENDPOINTS: Record<SwqosRegion, string>;
+declare const NEXT_BLOCK_ENDPOINTS: Record<SwqosRegion, string>;
+declare const SOYAS_ENDPOINTS: Record<SwqosRegion, string>;
+declare const SPEEDLANDING_ENDPOINTS: Record<SwqosRegion, string>;
+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;
+}
+declare abstract class BaseClient implements SwqosClient {
+    abstract getTipAccount(): string;
+    abstract getSwqosType(): SwqosType;
+    abstract minTipSol(): number;
+    abstract sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    sendTransactions(tradeType: TradeType, transactions: Buffer[], waitConfirmation: boolean): Promise<string[]>;
+    protected post(url: string, payload: unknown, headers?: Record<string, string>): Promise<unknown>;
+    protected postRaw(url: string, body: string, headers?: Record<string, string>): Promise<unknown>;
+}
+declare class JitoClient extends BaseClient {
+    private rpcUrl;
+    private endpoint;
+    private authToken?;
+    private tipAccounts;
+    constructor(rpcUrl: string, endpoint: string, authToken?: string | undefined);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    sendTransactions(tradeType: TradeType, transactions: Buffer[], waitConfirmation: boolean): Promise<string[]>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class BloxrouteClient extends BaseClient {
+    private rpcUrl;
+    private endpoint;
+    private authToken?;
+    private tipAccounts;
+    constructor(rpcUrl: string, endpoint: string, authToken?: string | undefined);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class ZeroSlotClient extends BaseClient {
+    private rpcUrl;
+    private endpoint;
+    private authToken?;
+    private tipAccounts;
+    constructor(rpcUrl: string, endpoint: string, authToken?: string | undefined);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class TemporalClient extends BaseClient {
+    private rpcUrl;
+    private endpoint;
+    private authToken?;
+    private tipAccounts;
+    constructor(rpcUrl: string, endpoint: string, authToken?: string | undefined);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class FlashBlockClient extends BaseClient {
+    private rpcUrl;
+    private endpoint;
+    private authToken?;
+    private tipAccounts;
+    constructor(rpcUrl: string, endpoint: string, authToken?: string | undefined);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class HeliusClient extends BaseClient {
+    private rpcUrl;
+    private endpoint;
+    private apiKey?;
+    private swqosOnly;
+    private tipAccounts;
+    constructor(rpcUrl: string, endpoint: string, apiKey?: string | undefined, swqosOnly?: boolean);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class Node1Client extends BaseClient {
+    private rpcUrl;
+    private endpoint;
+    private authToken?;
+    private tipAccounts;
+    constructor(rpcUrl: string, endpoint: string, authToken?: string | undefined);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class Node1QuicClient implements SwqosClient {
+    private readonly rpcUrl;
+    private readonly endpoint;
+    private readonly authToken;
+    private readonly tipAccounts;
+    private readonly host;
+    private readonly port;
+    constructor(rpcUrl: string, endpoint: string, authToken: string);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    sendTransactions(tradeType: TradeType, transactions: Buffer[], waitConfirmation: boolean): Promise<string[]>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class BlockRazorClient extends BaseClient {
+    private rpcUrl;
+    private endpoint;
+    private authToken?;
+    private mevProtection;
+    private tipAccounts;
+    constructor(rpcUrl: string, endpoint: string, authToken?: string | undefined, mevProtection?: boolean);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class AstralaneClient extends BaseClient {
+    private rpcUrl;
+    private endpoint;
+    private authToken?;
+    private tipAccounts;
+    constructor(rpcUrl: string, endpoint: string, authToken?: string | undefined);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class AstralaneQuicClient implements SwqosClient {
+    private readonly rpcUrl;
+    private readonly endpoint;
+    private readonly authToken;
+    private readonly tipAccounts;
+    private readonly host;
+    private readonly port;
+    constructor(rpcUrl: string, endpoint: string, authToken: string);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    sendTransactions(tradeType: TradeType, transactions: Buffer[], waitConfirmation: boolean): Promise<string[]>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class StelliumClient extends BaseClient {
+    private rpcUrl;
+    private endpoint;
+    private authToken?;
+    private tipAccounts;
+    constructor(rpcUrl: string, endpoint: string, authToken?: string | undefined);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class LightspeedClient extends BaseClient {
+    private rpcUrl;
+    private customUrl;
+    constructor(rpcUrl: string, customUrl: string);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class NextBlockClient extends BaseClient {
+    private rpcUrl;
+    private endpoint;
+    private authToken?;
+    private tipAccounts;
+    constructor(rpcUrl: string, endpoint: string, authToken?: string | undefined);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+declare class DefaultClient extends BaseClient {
+    private rpcUrl;
+    constructor(rpcUrl: string);
+    sendTransaction(tradeType: TradeType, transaction: Buffer, waitConfirmation: boolean): Promise<string>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+/**
+ * Soyas SWQOS client.
+ *
+ * Transport: QUIC with self-signed Ed25519 cert, ALPN "solana-tpu".
+ * Endpoint:  host:port (e.g. nyc.landing.soyas.xyz:9000)
+ * SNI:       "soyas-landing" (matches Rust SDK SOYAS_SERVER constant)
+ * Requires:  npm install @matrixai/quic selfsigned
+ */
+declare class SoyasClient implements SwqosClient {
+    private readonly rpcUrl;
+    private readonly endpoint;
+    private readonly apiKey?;
+    private readonly tipAccount;
+    private readonly host;
+    private readonly port;
+    constructor(rpcUrl: string, endpoint: string, apiKey?: string | undefined);
+    sendTransaction(_tradeType: TradeType, transaction: Buffer, _waitConfirmation: boolean): Promise<string>;
+    sendTransactions(tradeType: TradeType, transactions: Buffer[], waitConfirmation: boolean): Promise<string[]>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+/**
+ * Speedlanding SWQOS client.
+ *
+ * Transport: QUIC with self-signed Ed25519 cert, ALPN "solana-tpu".
+ * Endpoint:  host:port (e.g. nyc.speedlanding.trade:17778)
+ * SNI:       derived from hostname; falls back to "speed-landing" for bare IPs
+ *            (matches Rust SDK behavior).
+ * Requires:  npm install @matrixai/quic selfsigned
+ */
+declare class SpeedlandingClient implements SwqosClient {
+    private readonly rpcUrl;
+    private readonly endpoint;
+    private readonly apiKey?;
+    private readonly tipAccount;
+    private readonly host;
+    private readonly port;
+    private readonly serverName;
+    constructor(rpcUrl: string, endpoint: string, apiKey?: string | undefined);
+    sendTransaction(_tradeType: TradeType, transaction: Buffer, _waitConfirmation: boolean): Promise<string>;
+    sendTransactions(tradeType: TradeType, transactions: Buffer[], waitConfirmation: boolean): Promise<string[]>;
+    getTipAccount(): string;
+    getSwqosType(): SwqosType;
+    minTipSol(): number;
+}
+interface SwqosClientConfig {
+    type: SwqosType;
+    region?: SwqosRegion;
+    customUrl?: string;
+    apiKey?: string;
+    mevProtection?: boolean;
+    transport?: SwqosTransport;
+    astralaneTransport?: AstralaneTransport;
+    swqosOnly?: boolean;
+}
+declare class ClientFactory {
+    static createClient(config: SwqosClientConfig, rpcUrl: string): SwqosClient;
+}
+declare function createSwqosClient(swqosType: SwqosType, rpcUrl: string, authToken?: string, region?: SwqosRegion, customUrl?: string, mevProtection?: boolean): SwqosClient;
+
+/**
+ * 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"
+}
+declare enum TradeType$1 {
+    Buy = "Buy",
+    Sell = "Sell",
+    Create = "Create",
+    CreateAndBuy = "CreateAndBuy"
+}
+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 PumpFunParams$1 {
+    bondingCurve?: any;
+    associatedBondingCurve?: PublicKey;
+    creatorVault?: PublicKey;
+    tokenProgram?: PublicKey;
+    closeTokenAccountWhenSell?: boolean;
+}
+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 BonkParams$1 {
+    virtualBase?: bigint;
+    virtualQuote?: bigint;
+    realBase?: bigint;
+    realQuote?: bigint;
+    poolState?: PublicKey;
+    baseVault?: PublicKey;
+    quoteVault?: PublicKey;
+    mintTokenProgram?: PublicKey;
+    platformConfig?: PublicKey;
+    platformAssociatedAccount?: PublicKey;
+    creatorAssociatedAccount?: PublicKey;
+    globalConfig?: PublicKey;
+}
+interface RaydiumCpmmParams$1 {
+    poolState?: PublicKey;
+    ammConfig?: PublicKey;
+    baseMint?: PublicKey;
+    quoteMint?: PublicKey;
+    baseReserve?: bigint;
+    quoteReserve?: bigint;
+    baseVault?: PublicKey;
+    quoteVault?: PublicKey;
+    baseTokenProgram?: PublicKey;
+    quoteTokenProgram?: PublicKey;
+    observationState?: PublicKey;
+}
+interface RaydiumAmmV4Params$1 {
+    amm?: PublicKey;
+    coinMint?: PublicKey;
+    pcMint?: PublicKey;
+    tokenCoin?: PublicKey;
+    tokenPc?: PublicKey;
+    ammOpenOrders?: PublicKey;
+    ammTargetOrders?: PublicKey;
+    serumProgram?: PublicKey;
+    serumMarket?: PublicKey;
+    serumBids?: PublicKey;
+    serumAsks?: PublicKey;
+    serumEventQueue?: PublicKey;
+    serumCoinVaultAccount?: PublicKey;
+    serumPcVaultAccount?: PublicKey;
+    serumVaultSigner?: PublicKey;
+    coinReserve?: bigint;
+    pcReserve?: bigint;
+}
+interface MeteoraDammV2Params$1 {
+    pool?: PublicKey;
+    tokenAVault?: PublicKey;
+    tokenBVault?: PublicKey;
+    tokenAMint?: PublicKey;
+    tokenBMint?: PublicKey;
+    tokenAProgram?: PublicKey;
+    tokenBProgram?: PublicKey;
+}
+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;
+}
+interface ParserPumpFunTradeEvent {
+    mint?: string | PublicKey;
+    bonding_curve?: string | PublicKey;
+    associated_bonding_curve?: string | PublicKey;
+    creator?: string | PublicKey;
+    creator_vault?: string | PublicKey;
+    virtual_token_reserves?: bigint | number | string;
+    virtual_sol_reserves?: bigint | number | string;
+    virtual_quote_reserves?: bigint | number | string;
+    real_token_reserves?: bigint | number | string;
+    real_sol_reserves?: bigint | number | string;
+    real_quote_reserves?: bigint | number | string;
+    token_program?: string | PublicKey;
+    fee_recipient?: string | PublicKey;
+    quote_mint?: string | PublicKey;
+    is_cashback_coin?: boolean;
+    mayhem_mode?: boolean;
+}
+/**
+ * Build PumpFun params directly from a sol-parser-sdk PumpFunTradeEvent.
+ * The parser's `virtual_quote_reserves` / `real_quote_reserves` are mapped to
+ * the SDK's quote reserve fields used by slippage calculation.
+ */
+declare function pumpFunParamsFromParserTrade(event: ParserPumpFunTradeEvent, closeTokenAccountWhenSell?: boolean): PumpFunParams;
+/**
+ * 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;
+}
+interface ParserPumpSwapTradeEvent {
+    pool?: string | PublicKey;
+    base_mint?: string | PublicKey;
+    quote_mint?: string | PublicKey;
+    pool_base_token_account?: string | PublicKey;
+    pool_quote_token_account?: string | PublicKey;
+    pool_base_token_reserves?: bigint | number | string;
+    pool_quote_token_reserves?: bigint | number | string;
+    coin_creator_vault_ata?: string | PublicKey;
+    coin_creator_vault_authority?: string | PublicKey;
+    base_token_program?: string | PublicKey;
+    quote_token_program?: string | PublicKey;
+    is_mayhem_mode?: boolean;
+    is_cashback_coin?: boolean;
+}
+declare function pumpSwapParamsFromParserTrade(event: ParserPumpSwapTradeEvent): PumpSwapParams;
+/**
+ * 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;
+    ammOpenOrders: PublicKey;
+    ammTargetOrders: PublicKey;
+    serumProgram: PublicKey;
+    serumMarket: PublicKey;
+    serumBids: PublicKey;
+    serumAsks: PublicKey;
+    serumEventQueue: PublicKey;
+    serumCoinVaultAccount: PublicKey;
+    serumPcVaultAccount: PublicKey;
+    serumVaultSigner: PublicKey;
+    coinReserve: bigint;
+    pcReserve: bigint;
+}
+/**
+ * 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;
+    /** 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;
+    /**
+     * Deprecated compatibility field. Submit hot path starts every SWQOS/default RPC route
+     * immediately so the required default RPC lane is never delayed behind a local cap.
+     */
+    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 _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;
+    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;
+    private _swqosModulePromise?;
+    private _swqosClientCache;
+    constructor(payer: Keypair, config: TradeConfig);
+    private getSwqosModule;
+    private swqosClientCacheKey;
+    private getSwqosClient;
+    /** 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 { MIN_TIP_LIGHTSPEED as $, ASTRALANE_ENDPOINTS as A, type BatchTradeResult as B, ClientFactory as C, DexType$1 as D, DefaultClient as E, FLASH_BLOCK_ENDPOINTS as F, GasFeeStrategy as G, FlashBlockClient as H, type ITradeExecutor as I, HELIUS_ENDPOINTS as J, HeliusClient as K, JITO_ENDPOINTS as L, MeteoraDammV2Executor as M, JitoClient as N, LightspeedClient as O, PumpFunExecutor as P, MIN_TIP_ASTRALANE as Q, RaydiumAmmV4Executor as R, type SwqosClientConfig as S, TradeType$2 as T, MIN_TIP_BLOCK_RAZOR as U, MIN_TIP_BLOXROUTE as V, MIN_TIP_DEFAULT as W, MIN_TIP_FLASH_BLOCK as X, MIN_TIP_HELIUS as Y, MIN_TIP_HELIUS_NORMAL as Z, MIN_TIP_JITO as _, SwqosType$1 as a, DEFAULT_COMPUTE_UNITS as a$, MIN_TIP_NEXT_BLOCK as a0, MIN_TIP_NODE1 as a1, MIN_TIP_SOYAS as a2, MIN_TIP_SPEEDLANDING as a3, MIN_TIP_STELLIUM as a4, MIN_TIP_TEMPORAL as a5, MIN_TIP_ZERO_SLOT as a6, NEXT_BLOCK_ENDPOINTS as a7, NODE1_ENDPOINTS as a8, NextBlockClient as a9, BONK_POOL_STATE_SIZE as aA, BONK_POOL_VAULT_SEED as aB, BONK_PROGRAM as aC, BONK_PROGRAM_ID as aD, BONK_PROTOCOL_FEE_RATE as aE, BONK_SELL_EXACT_IN_DISCRIMINATOR as aF, BONK_SHARE_FEE_RATE as aG, BONK_USD1_GLOBAL_CONFIG as aH, BYTES_PER_ACCOUNT as aI, BaseExecutor as aJ, type BondingCurveAccount as aK, type BonkBuildBuyParams as aL, type BonkBuildSellParams as aM, type BonkParams as aN, type BonkPoolState as aO, type BonkVestingSchedule as aP, type BuildBuyParams as aQ, type BuildMeteoraDammV2BuyInstructionsParams as aR, type BuildMeteoraDammV2SellInstructionsParams as aS, type BuildRaydiumAmmV4BuyInstructionsParams as aT, type BuildRaydiumAmmV4SellInstructionsParams as aU, type BuildRaydiumCpmmBuyInstructionsParams as aV, type BuildRaydiumCpmmSellInstructionsParams as aW, type BuildSellParams as aX, CONSTANTS as aY, type ConfirmAnySignatureOptions as aZ, ContextExpiredError as a_, Node1Client as aa, Node1QuicClient as ab, SOYAS_ENDPOINTS as ac, SPEEDLANDING_ENDPOINTS as ad, STELLIUM_ENDPOINTS as ae, SoyasClient as af, SpeedlandingClient as ag, StelliumClient as ah, TEMPORAL_ENDPOINTS as ai, TemporalClient as aj, ZERO_SLOT_ENDPOINTS as ak, ZeroSlotClient as al, createSwqosClient as am, randomChoice as an, AMM_INFO_SIZE as ao, ASSOCIATED_TOKEN_PROGRAM as ap, type AccountState as aq, type AddressLookupTableAccount as ar, AddressLookupTableCache as as, AstralaneTransport as at, BONK_AUTHORITY as au, BONK_BUY_EXACT_IN_DISCRIMINATOR as av, BONK_EVENT_AUTHORITY as aw, BONK_GLOBAL_CONFIG as ax, BONK_PLATFORM_FEE_RATE as ay, BONK_POOL_SEED as az, type SwqosClient as b, PUMPFUN_SELL_DISCRIMINATOR as b$, DEFAULT_PRIORITY_FEE as b0, DEFAULT_SLIPPAGE as b1, DEFAULT_TIP_LAMPORTS as b2, type DexParamEnum as b3, DexType as b4, type DurableNonceInfo as b5, type ExecuteOptions as b6, type ExecuteResult as b7, ExecutionPath as b8, type FetchedDurableNonce as b9, type MeteoraDammV2Pool as bA, MetricsMiddleware as bB, type Middleware as bC, type MiddlewareContext as bD, MiddlewareManager as bE, MissingAccountError as bF, POOL_SIZE as bG, PUMPFUN_BONDING_CURVE_SEED as bH, PUMPFUN_BONDING_CURVE_V2_SEED as bI, PUMPFUN_BUYBACK_FEE_RECIPIENTS as bJ, PUMPFUN_BUY_DISCRIMINATOR as bK, PUMPFUN_BUY_EXACT_QUOTE_IN_V2_DISCRIMINATOR as bL, PUMPFUN_BUY_EXACT_SOL_IN_DISCRIMINATOR as bM, PUMPFUN_BUY_V2_DISCRIMINATOR as bN, PUMPFUN_CLAIM_CASHBACK_DISCRIMINATOR as bO, PUMPFUN_CREATOR_VAULT_SEED as bP, PUMPFUN_DISCRIMINATORS as bQ, PUMPFUN_EVENT_AUTHORITY as bR, PUMPFUN_FEE_CONFIG as bS, PUMPFUN_FEE_PROGRAM as bT, PUMPFUN_FEE_RECIPIENT as bU, PUMPFUN_GLOBAL_ACCOUNT as bV, PUMPFUN_GLOBAL_VOLUME_ACCUMULATOR as bW, PUMPFUN_MAYHEM_FEE_RECIPIENTS as bX, PUMPFUN_PROGRAM as bY, PUMPFUN_PROGRAM_ID as bZ, PUMPFUN_PROTOCOL_EXTRA_FEE_RECIPIENTS as b_, FilterMiddleware as ba, type GasFeeConfig as bb, type GasFeeStrategyConfig as bc, type GasFeeStrategyValue as bd, type HotPathConfig as be, HotPathError as bf, HotPathExecutor as bg, HotPathMetrics as bh, HotPathState as bi, type InstructionMiddleware as bj, InstructionProcessor as bk, KNOWN_PROGRAM_IDS as bl, type KeyMetadata as bm, KeyNotAvailableError as bn, LoggingMiddleware as bo, MARKET_STATE_SIZE as bp, MAX_INSTRUCTIONS_WARN as bq, METEORA_DAMM_V2_AUTHORITY as br, METEORA_DAMM_V2_EVENT_AUTHORITY_SEED as bs, METEORA_DAMM_V2_PROGRAM as bt, METEORA_DAMM_V2_PROGRAM_ID as bu, METEORA_DAMM_V2_SWAP2_DISCRIMINATOR as bv, METEORA_DAMM_V2_SWAP_DISCRIMINATOR as bw, METEORA_DAMM_V2_SWAP_MODE_PARTIAL_FILL as bx, METEORA_POOL_SIZE as by, type MeteoraDammV2Params as bz, GasFeeStrategyType as c, type RaydiumCpmmParams as c$, PUMPFUN_SELL_V2_DISCRIMINATOR as c0, PUMPFUN_SHARING_CONFIG_SEED as c1, PUMPFUN_STANDARD_FEE_RECIPIENTS as c2, PUMPFUN_USER_VOLUME_ACCUMULATOR_SEED as c3, PUMPSWAP_BUY_DISCRIMINATOR as c4, PUMPSWAP_BUY_EXACT_QUOTE_IN_DISCRIMINATOR as c5, PUMPSWAP_CLAIM_CASHBACK_DISCRIMINATOR as c6, PUMPSWAP_DEFAULT_COIN_CREATOR_VAULT_AUTHORITY as c7, PUMPSWAP_DISCRIMINATORS as c8, PUMPSWAP_EVENT_AUTHORITY as c9, RAYDIUM_AMM_V4_SWAP_BASE_IN_DISCRIMINATOR as cA, RAYDIUM_AMM_V4_SWAP_BASE_OUT_DISCRIMINATOR as cB, RAYDIUM_AMM_V4_SWAP_FEE_DENOMINATOR as cC, RAYDIUM_AMM_V4_SWAP_FEE_NUMERATOR as cD, RAYDIUM_AMM_V4_TRADE_FEE_DENOMINATOR as cE, RAYDIUM_AMM_V4_TRADE_FEE_NUMERATOR as cF, RAYDIUM_CPMM_AUTHORITY as cG, RAYDIUM_CPMM_CREATOR_FEE_RATE as cH, RAYDIUM_CPMM_FEE_RATE_DENOMINATOR_VALUE as cI, RAYDIUM_CPMM_FUND_FEE_RATE as cJ, RAYDIUM_CPMM_OBSERVATION_STATE_SEED as cK, RAYDIUM_CPMM_POOL_SEED as cL, RAYDIUM_CPMM_POOL_STATE_SIZE as cM, RAYDIUM_CPMM_POOL_VAULT_SEED as cN, RAYDIUM_CPMM_PROGRAM as cO, RAYDIUM_CPMM_PROGRAM_ID as cP, RAYDIUM_CPMM_PROTOCOL_FEE_RATE as cQ, RAYDIUM_CPMM_SWAP_BASE_IN_DISCRIMINATOR as cR, RAYDIUM_CPMM_SWAP_BASE_OUT_DISCRIMINATOR as cS, RAYDIUM_CPMM_TRADE_FEE_RATE as cT, RENT as cU, RUST_PARITY_SIMULATE_CONFIG as cV, type RaydiumAmmFees as cW, type RaydiumAmmInfo as cX, type RaydiumAmmOutputData as cY, type RaydiumAmmV4Params as cZ, type RaydiumCPMMpoolState as c_, PUMPSWAP_FEE_CONFIG as ca, PUMPSWAP_FEE_PROGRAM as cb, PUMPSWAP_FEE_RECIPIENT as cc, PUMPSWAP_GLOBAL_ACCOUNT as cd, PUMPSWAP_GLOBAL_VOLUME_ACCUMULATOR as ce, PUMPSWAP_MAYHEM_FEE_RECIPIENTS as cf, PUMPSWAP_PROGRAM as cg, PUMPSWAP_PROGRAM_ID as ch, PUMPSWAP_PROTOCOL_EXTRA_FEE_RECIPIENTS as ci, PUMPSWAP_PUMP_PROGRAM_ID as cj, PUMPSWAP_SELL_DISCRIMINATOR as ck, type ParserPumpFunTradeEvent as cl, type ParserPumpSwapTradeEvent as cm, type PoolState as cn, Prefetch as co, type PrefetchedData as cp, type PumpFunBondingCurve as cq, type PumpFunBuildBuyParams as cr, type PumpFunBuildSellParams as cs, type PumpFunParams as ct, type PumpSwapParams as cu, type PumpSwapPool as cv, RAYDIUM_AMM_V4_AUTHORITY as cw, RAYDIUM_AMM_V4_POOL_SEED as cx, RAYDIUM_AMM_V4_PROGRAM as cy, RAYDIUM_AMM_V4_PROGRAM_ID as cz, SwqosType as d, createTradeConfig as d$, type RaydiumMarketState as d0, SDK_FEE_RECIPIENT as d1, SDK_MAYHEM_FEE_RECIPIENTS as d2, SOL_TOKEN_ACCOUNT as d3, SWQOS_ENDPOINTS as d4, SYSTEM_PROGRAM as d5, SecureKeyError as d6, SecureKeyStorage as d7, StaleBlockhashError as d8, type SwqosConfig as d9, buildBonkBuyInstructions as dA, buildBonkSellInstructions as dB, buildBuyInstructions as dC, buildClaimCashbackInstruction as dD, buildMeteoraDammV2BuyInstructions as dE, buildMeteoraDammV2SellInstructions as dF, buildPumpFunBuyInstructions as dG, buildPumpFunBuyV2Instructions as dH, buildPumpFunClaimCashbackInstruction as dI, buildPumpFunSellInstructions as dJ, buildPumpFunSellV2Instructions as dK, buildRaydiumAmmV4BuyInstructions as dL, buildRaydiumAmmV4SellInstructions as dM, buildRaydiumCpmmBuyInstructions as dN, buildRaydiumCpmmSellInstructions as dO, buildSellInstructions as dP, calculatePriceImpact as dQ, calculateWithSlippageBuy as dR, calculateWithSlippageSell as dS, closeWsol as dT, commitmentToGetTxFinality as dU, computeRaydiumAmmV4SwapAmount as dV, computeRaydiumCpmmSwapAmount as dW, confirmAnyTransactionSignature as dX, createAssociatedTokenAccountIdempotent as dY, createGasFeeStrategy as dZ, createHotPathExecutor as d_, SwqosRegion as da, type SwqosTiming as db, SwqosTransport as dc, TOKEN_PROGRAM as dd, TOKEN_PROGRAM_2022 as de, TimerMiddleware as df, type TradeBuyParams as dg, type TradeConfig as dh, TradeConfigBuilder as di, TradeError as dj, type TradeResult as dk, type TradeSellParams as dl, TradeTokenType as dm, TradingClient as dn, TradingContext as dp, TransactionBuilder as dq, USD1_MINT as dr, USD1_TOKEN_ACCOUNT as ds, USDC_MINT as dt, USDC_TOKEN_ACCOUNT as du, ValidationError as dv, ValidationMiddleware as dw, WSOL_MINT as dx, WSOL_TOKEN_ACCOUNT as dy, addressLookupTableCache as dz, TradeType as e, getUserVolumeAccumulatorPDA as e$, decodeAmmInfo as e0, decodeBonkPoolState as e1, decodeMarketState as e2, decodeMeteoraPool as e3, decodePool as e4, decodeRaydiumCPMMpoolState as e5, defaultExecuteOptions as e6, defaultHotPathConfig as e7, deriveSerumVaultSigner as e8, extractHintsFromLogs as e9, getCoinCreatorVaultAta as eA, getCoinCreatorVaultAuthority as eB, getCreator as eC, getCreatorVaultPda as eD, getFeeConfigPDA as eE, getFeeRecipientAta as eF, getGlobalVolumeAccumulatorPDA as eG, getMayhemFeeRecipientRandom as eH, getMeteoraDammV2EventAuthorityPda as eI, getPoolV2PDA as eJ, getPumpFunBuybackFeeRecipientRandom as eK, getPumpFunFeeSharingConfigPda as eL, getPumpFunProtocolExtraFeeRecipientRandom as eM, getPumpFunUserVolumeAccumulatorPda as eN, getPumpPoolAuthorityPDA as eO, getPumpSwapProtocolExtraFeeRecipientRandom as eP, getRandomMayhemFeeRecipient as eQ, getRaydiumCPMMobservationStatePDA as eR, getRaydiumCPMMpoolPDA as eS, getRaydiumCPMMpoolTokenBalances as eT, getRaydiumCPMMvaultPDA as eU, getRaydiumCpmmObservationStatePda as eV, getRaydiumCpmmPoolPda as eW, getRaydiumCpmmVaultPda as eX, getSellSolAmountFromTokenAmount as eY, getStandardFeeRecipientRandom as eZ, getTokenBalances as e_, fetchAddressLookupTableAccount as ea, fetchAmmInfo as eb, fetchBondingCurveAccount as ec, fetchBonkPoolState as ed, fetchDurableNonceInfo as ee, fetchMarketState as ef, fetchMeteoraPool as eg, fetchPool as eh, fetchRaydiumCPMMpoolState as ei, findByBaseMint as ej, findByMint as ek, findByQuoteMint as el, findPoolByMint as em, formatPublicKey as en, getAssociatedTokenAddress as eo, getBondingCurvePda as ep, getBondingCurveV2Pda as eq, getBonkCreatorAssociatedAccount as er, getBonkPlatformAssociatedAccount as es, getBonkPoolPDA as et, getBonkPoolPda as eu, getBonkVaultPDA as ev, getBonkVaultPda as ew, getBuyPrice as ex, getBuyTokenAmountFromSolAmount as ey, getCanonicalPoolPDA as ez, BonkExecutor as f, getUserVolumeAccumulatorQuoteAta as f0, getUserVolumeAccumulatorWsolAta as f1, handleWsol as f2, instructionErrorCodeFromMetaErr as f3, isValidPublicKey as f4, lamportsToSol as f5, mapWithConcurrencyLimit as f6, nowMicroseconds as f7, parseAddressLookupTable as f8, pumpFunFeeRecipientMeta as f9, pumpFunParamsFromParserTrade as fa, pumpSwapParamsFromParserTrade as fb, recommendedSenderThreadCoreIndices as fc, retryWithBackoff as fd, signWithKeypair as fe, sleep as ff, solToLamports as fg, validateAmount as fh, validateMintPair as fi, validateProgramId as fj, validatePubkey as fk, validateRpcUrl as fl, validateSignature as fm, validateSlippage as fn, validateTransactionSize as fo, withAllBuiltinMiddlewares as fp, withStandardMiddlewares as fq, type BonkParams$1 as g, type TradeResult$1 as h, TradeType$1 as i, type MeteoraDammV2Params$1 as j, type PumpFunParams$1 as k, PumpSwapExecutor as l, type PumpSwapParams$1 as m, type RaydiumAmmV4Params$1 as n, RaydiumCpmmExecutor as o, type RaydiumCpmmParams$1 as p, type TradeExecuteOptions as q, TradeExecutorFactory as r, defaultTradeExecuteOptions as s, ASTRALANE_QUIC_HOSTS as t, AstralaneClient as u, AstralaneQuicClient as v, BLOCK_RAZOR_ENDPOINTS as w, BLOXROUTE_ENDPOINTS as x, BlockRazorClient as y, BloxrouteClient as z };