sol-trade-sdk 0.1.0 → 0.1.2

package/dist/{chunk-NEZDFAYA.mjs → chunk-H4ZUMTTP.mjs}

@@ -230,14 +230,15 @@ import {
 } from "@solana/web3.js";
 import {
   getAssociatedTokenAddressSync,
-  createAssociatedTokenAccountInstruction,
   createAssociatedTokenAccountIdempotentInstruction,
   TOKEN_PROGRAM_ID,
   TOKEN_2022_PROGRAM_ID,
   ASSOCIATED_TOKEN_PROGRAM_ID as SPL_ASSOCIATED_TOKEN_PROGRAM_ID,
   createCloseAccountInstruction,
+  createSyncNativeInstruction,
   NATIVE_MINT
 } from "@solana/spl-token";
+var SOL_TOKEN_ACCOUNT2 = new PublicKey2("So11111111111111111111111111111111111111111");
 var PUMPFUN_PROGRAM_ID = new PublicKey2(
   "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"
 );
@@ -489,7 +490,36 @@ function effectivePumpMintTokenProgram(mint, protocolParams) {
   return TOKEN_2022_PROGRAM_ID;
 }
 function effectiveQuoteMint(protocolParams) {
-  return isUsablePubkey(protocolParams.quoteMint) ? protocolParams.quoteMint : NATIVE_MINT;
+  if (!isUsablePubkey(protocolParams.quoteMint) || protocolParams.quoteMint.equals(SOL_TOKEN_ACCOUNT2)) {
+    return NATIVE_MINT;
+  }
+  return protocolParams.quoteMint;
+}
+function usesPumpFunV2Layout(protocolParams) {
+  return isUsablePubkey(protocolParams.quoteMint) && !protocolParams.quoteMint.equals(SOL_TOKEN_ACCOUNT2);
+}
+function isSolQuoteMint(mint) {
+  return mint.equals(SOL_TOKEN_ACCOUNT2) || mint.equals(NATIVE_MINT);
+}
+function validateV2BuyQuoteMint(inputMint, quoteMint) {
+  if (isSolQuoteMint(quoteMint)) {
+    if (inputMint.equals(SOL_TOKEN_ACCOUNT2) || inputMint.equals(NATIVE_MINT)) return;
+  } else if (inputMint.equals(quoteMint)) {
+    return;
+  }
+  throw new Error(
+    `PumpFun V2 buy input_mint ${inputMint.toBase58()} does not match quote_mint ${quoteMint.toBase58()}; USDC quote pools must be bought with USDC, not SOL`
+  );
+}
+function validateV2SellQuoteMint(outputMint, quoteMint) {
+  if (isSolQuoteMint(quoteMint)) {
+    if (outputMint.equals(SOL_TOKEN_ACCOUNT2) || outputMint.equals(NATIVE_MINT)) return;
+  } else if (outputMint.equals(quoteMint)) {
+    return;
+  }
+  throw new Error(
+    `PumpFun V2 sell output_mint ${outputMint.toBase58()} does not match quote_mint ${quoteMint.toBase58()}; USDC quote pools settle to USDC, not SOL`
+  );
 }
 function associatedTokenAddress(mint, owner, tokenProgram) {
   return getAssociatedTokenAddressSync(
@@ -500,6 +530,28 @@ function associatedTokenAddress(mint, owner, tokenProgram) {
     SPL_ASSOCIATED_TOKEN_PROGRAM_ID
   );
 }
+function pushCreateOrWrapUserTokenAccount(instructions, payer, ata, mint, tokenProgram, amount) {
+  instructions.push(
+    createAssociatedTokenAccountIdempotentInstruction(
+      payer,
+      ata,
+      payer,
+      mint,
+      tokenProgram,
+      SPL_ASSOCIATED_TOKEN_PROGRAM_ID
+    )
+  );
+  if (mint.equals(NATIVE_MINT)) {
+    instructions.push(
+      SystemProgram.transfer({
+        fromPubkey: payer,
+        toPubkey: ata,
+        lamports: amount
+      })
+    );
+    instructions.push(createSyncNativeInstruction(ata));
+  }
+}
 function getBuyTokenAmountFromSolAmount(amount, bondingCurve, creator) {
   if (amount === 0n || bondingCurve.virtualTokenReserves === 0n) {
     return 0n;
@@ -529,21 +581,23 @@ function getSellSolAmountFromTokenAmount(amount, bondingCurve, creator) {
 function buildPumpFunBuyInstructions(params) {
   const {
     payer,
+    inputMint = SOL_TOKEN_ACCOUNT2,
     outputMint,
     inputAmount,
     slippageBasisPoints = BigInt(1e3),
     fixedOutputAmount,
     createOutputMintAta = true,
     createInputMintAta = false,
+    closeInputMintAta = false,
     protocolParams,
-    useExactSolAmount = true,
-    usePumpFunV2 = false
+    useExactSolAmount = true
   } = params;
-  if (usePumpFunV2 || protocolParams.useV2Ix || isUsablePubkey(protocolParams.quoteMint)) {
+  if (usesPumpFunV2Layout(protocolParams)) {
     return buildPumpFunBuyV2Instructions({
       ...params,
+      inputMint,
       createInputMintAta,
-      usePumpFunV2: true
+      closeInputMintAta
     });
   }
   if (inputAmount === BigInt(0)) {
@@ -567,34 +621,41 @@ function buildPumpFunBuyInstructions(params) {
   const userVolumeAccumulator = getPumpFunUserVolumeAccumulatorPda(payerPubkey);
   if (createOutputMintAta) {
     instructions.push(
-      createAssociatedTokenAccountInstruction(
+      createAssociatedTokenAccountIdempotentInstruction(
         payerPubkey,
         userTokenAccount,
         payerPubkey,
         outputMint,
-        tokenProgramId
+        tokenProgramId,
+        SPL_ASSOCIATED_TOKEN_PROGRAM_ID
       )
     );
   }
   const feeRecipientPk = pumpFunFeeRecipientMeta(feeRecipient, bondingCurve.isMayhemMode);
   const bondingCurveV2 = getBondingCurveV2Pda(outputMint);
-  const trackVolume = bondingCurve.isCashbackCoin ? Buffer.from([1, 1]) : Buffer.from([1, 0]);
+  const trackVolume = bondingCurve.isCashbackCoin ? 1 : 0;
   const buyTokenAmount = fixedOutputAmount ? fixedOutputAmount : getBuyTokenAmountFromSolAmount(inputAmount, bondingCurve, creator);
   const maxSolCost = calculateWithSlippageBuy(inputAmount, slippageBasisPoints);
   let data;
-  if (useExactSolAmount) {
-    const minTokensOut = fixedOutputAmount ? fixedOutputAmount : calculateWithSlippageSell(buyTokenAmount, slippageBasisPoints);
-    data = Buffer.alloc(26);
+  if (fixedOutputAmount !== void 0) {
+    data = Buffer.alloc(25);
+    PUMPFUN_BUY_DISCRIMINATOR.copy(data, 0);
+    data.writeBigUInt64LE(fixedOutputAmount, 8);
+    data.writeBigUInt64LE(inputAmount, 16);
+    data[24] = trackVolume;
+  } else if (useExactSolAmount) {
+    const minTokensOut = calculateWithSlippageSell(buyTokenAmount, slippageBasisPoints);
+    data = Buffer.alloc(25);
     PUMPFUN_BUY_EXACT_SOL_IN_DISCRIMINATOR.copy(data, 0);
     data.writeBigUInt64LE(inputAmount, 8);
     data.writeBigUInt64LE(minTokensOut, 16);
-    trackVolume.copy(data, 24);
+    data[24] = trackVolume;
   } else {
-    data = Buffer.alloc(26);
+    data = Buffer.alloc(25);
     PUMPFUN_BUY_DISCRIMINATOR.copy(data, 0);
     data.writeBigUInt64LE(buyTokenAmount, 8);
     data.writeBigUInt64LE(maxSolCost, 16);
-    trackVolume.copy(data, 24);
+    data[24] = trackVolume;
   }
   const keys = [
     { pubkey: PUMPFUN_GLOBAL_ACCOUNT, isSigner: false, isWritable: false },
@@ -629,19 +690,19 @@ function buildPumpFunSellInstructions(params) {
   const {
     payer,
     inputMint,
+    outputMint = SOL_TOKEN_ACCOUNT2,
     inputAmount,
     slippageBasisPoints = BigInt(1e3),
     fixedOutputAmount,
     createOutputMintAta = false,
     closeInputMintAta = false,
-    protocolParams,
-    usePumpFunV2 = false
+    protocolParams
   } = params;
-  if (usePumpFunV2 || protocolParams.useV2Ix || isUsablePubkey(protocolParams.quoteMint)) {
+  if (usesPumpFunV2Layout(protocolParams)) {
     return buildPumpFunSellV2Instructions({
       ...params,
-      createOutputMintAta,
-      usePumpFunV2: true
+      outputMint,
+      createOutputMintAta
     });
   }
   if (inputAmount === BigInt(0)) {
@@ -721,12 +782,14 @@ function buildPumpFunSellInstructions(params) {
 function buildPumpFunBuyV2Instructions(params) {
   const {
     payer,
+    inputMint = SOL_TOKEN_ACCOUNT2,
     outputMint,
     inputAmount,
     slippageBasisPoints = BigInt(1e3),
     fixedOutputAmount,
     createOutputMintAta = true,
     createInputMintAta = false,
+    closeInputMintAta = false,
     protocolParams,
     useExactSolAmount = true
   } = params;
@@ -741,6 +804,7 @@ function buildPumpFunBuyV2Instructions(params) {
   const bondingCurveAddr = bondingCurve.account.equals(PublicKey2.default) || !bondingCurve.account ? getBondingCurvePda(outputMint) : bondingCurve.account;
   const baseTokenProgram = effectivePumpMintTokenProgram(outputMint, protocolParams);
   const quoteMint = effectiveQuoteMint(protocolParams);
+  validateV2BuyQuoteMint(inputMint, quoteMint);
   const quoteTokenProgram = TOKEN_PROGRAM_ID;
   const associatedBaseBondingCurve = associatedTokenAddress(
     outputMint,
@@ -793,32 +857,39 @@ function buildPumpFunBuyV2Instructions(params) {
       )
     );
   }
-  if (createInputMintAta) {
-    instructions.push(
-      createAssociatedTokenAccountIdempotentInstruction(
-        payerPubkey,
-        associatedQuoteUser,
-        payerPubkey,
-        quoteMint,
-        quoteTokenProgram,
-        SPL_ASSOCIATED_TOKEN_PROGRAM_ID
-      )
-    );
-  }
   const buyTokenAmount = fixedOutputAmount ? fixedOutputAmount : getBuyTokenAmountFromSolAmount(inputAmount, bondingCurve, creator);
   const maxSolCost = calculateWithSlippageBuy(inputAmount, slippageBasisPoints);
   let data;
-  if (useExactSolAmount) {
-    const minTokensOut = fixedOutputAmount ? fixedOutputAmount : calculateWithSlippageSell(buyTokenAmount, slippageBasisPoints);
+  let quoteAmountToFund;
+  if (fixedOutputAmount !== void 0) {
+    data = Buffer.alloc(24);
+    PUMPFUN_BUY_V2_DISCRIMINATOR.copy(data, 0);
+    data.writeBigUInt64LE(fixedOutputAmount, 8);
+    data.writeBigUInt64LE(inputAmount, 16);
+    quoteAmountToFund = inputAmount;
+  } else if (useExactSolAmount) {
+    const minTokensOut = calculateWithSlippageSell(buyTokenAmount, slippageBasisPoints);
     data = Buffer.alloc(24);
     PUMPFUN_BUY_EXACT_QUOTE_IN_V2_DISCRIMINATOR.copy(data, 0);
     data.writeBigUInt64LE(inputAmount, 8);
     data.writeBigUInt64LE(minTokensOut, 16);
+    quoteAmountToFund = inputAmount;
   } else {
     data = Buffer.alloc(24);
     PUMPFUN_BUY_V2_DISCRIMINATOR.copy(data, 0);
     data.writeBigUInt64LE(buyTokenAmount, 8);
     data.writeBigUInt64LE(maxSolCost, 16);
+    quoteAmountToFund = maxSolCost;
+  }
+  if (createInputMintAta) {
+    pushCreateOrWrapUserTokenAccount(
+      instructions,
+      payerPubkey,
+      associatedQuoteUser,
+      quoteMint,
+      quoteTokenProgram,
+      quoteAmountToFund
+    );
   }
   const keys = [
     { pubkey: PUMPFUN_GLOBAL_ACCOUNT, isSigner: false, isWritable: false },
@@ -856,12 +927,24 @@ function buildPumpFunBuyV2Instructions(params) {
       data
     })
   );
+  if (closeInputMintAta && quoteMint.equals(NATIVE_MINT)) {
+    instructions.push(
+      createCloseAccountInstruction(
+        associatedQuoteUser,
+        payerPubkey,
+        payerPubkey,
+        [],
+        quoteTokenProgram
+      )
+    );
+  }
   return instructions;
 }
 function buildPumpFunSellV2Instructions(params) {
   const {
     payer,
     inputMint,
+    outputMint = SOL_TOKEN_ACCOUNT2,
     inputAmount,
     slippageBasisPoints = BigInt(1e3),
     fixedOutputAmount,
@@ -880,6 +963,7 @@ function buildPumpFunSellV2Instructions(params) {
   const bondingCurveAddr = bondingCurve.account.equals(PublicKey2.default) || !bondingCurve.account ? getBondingCurvePda(inputMint) : bondingCurve.account;
   const baseTokenProgram = effectivePumpMintTokenProgram(inputMint, protocolParams);
   const quoteMint = effectiveQuoteMint(protocolParams);
+  validateV2SellQuoteMint(outputMint, quoteMint);
   const quoteTokenProgram = TOKEN_PROGRAM_ID;
   const associatedBaseBondingCurve = associatedTokenAddress(
     inputMint,
@@ -1895,7 +1979,7 @@ import {
 } from "@solana/web3.js";
 import {
   getAssociatedTokenAddressSync as getAssociatedTokenAddressSync2,
-  createAssociatedTokenAccountInstruction as createAssociatedTokenAccountInstruction2,
+  createAssociatedTokenAccountInstruction,
   TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID2,
   createCloseAccountInstruction as createCloseAccountInstruction2,
   NATIVE_MINT as NATIVE_MINT2,
@@ -2040,7 +2124,7 @@ function buildBonkBuyInstructions(params) {
   if (createInputMintAta && !isUsd1Pool) {
     const wsolAta = getAssociatedTokenAddressSync2(NATIVE_MINT2, payerPubkey, true, TOKEN_PROGRAM_ID2);
     instructions.push(
-      createAssociatedTokenAccountInstruction2(payerPubkey, wsolAta, payerPubkey, NATIVE_MINT2)
+      createAssociatedTokenAccountInstruction(payerPubkey, wsolAta, payerPubkey, NATIVE_MINT2)
     );
     const transferIx = SystemProgram3.transfer({
       fromPubkey: payerPubkey,
@@ -2052,7 +2136,7 @@ function buildBonkBuyInstructions(params) {
   }
   if (createOutputMintAta) {
     instructions.push(
-      createAssociatedTokenAccountInstruction2(
+      createAssociatedTokenAccountInstruction(
         payerPubkey,
         userBaseTokenAccount,
         payerPubkey,
@@ -2151,7 +2235,7 @@ function buildBonkSellInstructions(params) {
   if (createOutputMintAta && !isUsd1Pool) {
     const wsolAta = getAssociatedTokenAddressSync2(NATIVE_MINT2, payerPubkey, true, TOKEN_PROGRAM_ID2);
     instructions.push(
-      createAssociatedTokenAccountInstruction2(payerPubkey, wsolAta, payerPubkey, NATIVE_MINT2)
+      createAssociatedTokenAccountInstruction(payerPubkey, wsolAta, payerPubkey, NATIVE_MINT2)
     );
   }
   const shareFeeRate = BigInt(0);
@@ -2318,14 +2402,13 @@ function getBonkVaultPDA(poolState, mint) {
 import {
   PublicKey as PublicKey5,
   Keypair as Keypair3,
-  TransactionInstruction as TransactionInstruction4
+  TransactionInstruction as TransactionInstruction4,
+  SystemProgram as SystemProgram4
 } from "@solana/web3.js";
 import {
   getAssociatedTokenAddressSync as getAssociatedTokenAddressSync3,
-  createAssociatedTokenAccountInstruction as createAssociatedTokenAccountInstruction3,
-  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID3,
+  createAssociatedTokenAccountIdempotentInstruction as createAssociatedTokenAccountIdempotentInstruction2,
   createCloseAccountInstruction as createCloseAccountInstruction3,
-  NATIVE_MINT as NATIVE_MINT3,
   createSyncNativeInstruction as createSyncNativeInstruction3
 } from "@solana/spl-token";
 var RAYDIUM_CPMM_PROGRAM_ID = new PublicKey5(
@@ -2435,34 +2518,38 @@ function buildRaydiumCpmmBuyInstructions(params) {
     throw new Error("Pool must contain WSOL or USDC");
   }
   const isBaseIn = baseMint.equals(WSOL_TOKEN_ACCOUNT2) || baseMint.equals(USDC_TOKEN_ACCOUNT2);
-  const mintTokenProgram = isBaseIn ? quoteTokenProgram : baseTokenProgram;
+  const inputMint = isBaseIn ? baseMint : quoteMint;
+  const inputTokenProgram = isBaseIn ? baseTokenProgram : quoteTokenProgram;
+  const expectedOutputMint = isBaseIn ? quoteMint : baseMint;
+  const outputTokenProgram = isBaseIn ? quoteTokenProgram : baseTokenProgram;
+  if (!outputMint.equals(expectedOutputMint)) {
+    throw new Error(`outputMint must match Raydium CPMM pool side ${expectedOutputMint.toBase58()}`);
+  }
   const poolState = protocolParams.poolState && !protocolParams.poolState.equals(PublicKey5.default) ? protocolParams.poolState : getRaydiumCpmmPoolPda(ammConfig, baseMint, quoteMint);
-  const swapResult = computeRaydiumCpmmSwapAmount(
+  const minimumAmountOut = fixedOutputAmount ?? computeRaydiumCpmmSwapAmount(
     baseReserve,
     quoteReserve,
     isBaseIn,
     inputAmount,
     slippageBasisPoints
-  );
-  const minimumAmountOut = fixedOutputAmount || swapResult.minAmountOut;
-  const inputMint = isWsol ? WSOL_TOKEN_ACCOUNT2 : USDC_TOKEN_ACCOUNT2;
+  ).minAmountOut;
   const inputTokenAccount = getAssociatedTokenAddressSync3(
     inputMint,
     payerPubkey,
     true,
-    TOKEN_PROGRAM_ID3
+    inputTokenProgram
   );
   const outputTokenAccount = getAssociatedTokenAddressSync3(
     outputMint,
     payerPubkey,
     true,
-    mintTokenProgram
+    outputTokenProgram
   );
   const inputVaultAccount = (() => {
-    if (isWsol && baseMint.equals(inputMint) && baseVault && !baseVault.equals(PublicKey5.default)) {
+    if (baseMint.equals(inputMint) && baseVault && !baseVault.equals(PublicKey5.default)) {
       return baseVault;
     }
-    if (!isWsol && quoteMint.equals(inputMint) && quoteVault && !quoteVault.equals(PublicKey5.default)) {
+    if (quoteMint.equals(inputMint) && quoteVault && !quoteVault.equals(PublicKey5.default)) {
       return quoteVault;
     }
     return getRaydiumCpmmVaultPda(poolState, inputMint);
@@ -2477,34 +2564,43 @@ function buildRaydiumCpmmBuyInstructions(params) {
     return getRaydiumCpmmVaultPda(poolState, outputMint);
   })();
   const observationStateAccount = observationState && !observationState.equals(PublicKey5.default) ? observationState : getRaydiumCpmmObservationStatePda(poolState);
-  if (createInputMintAta && isWsol) {
-    const wsolAta = getAssociatedTokenAddressSync3(NATIVE_MINT3, payerPubkey, true);
+  if (createInputMintAta) {
+    const isInputWsol = inputMint.equals(WSOL_TOKEN_ACCOUNT2);
     instructions.push(
-      createAssociatedTokenAccountInstruction3(
+      createAssociatedTokenAccountIdempotentInstruction2(
         payerPubkey,
-        wsolAta,
+        inputTokenAccount,
         payerPubkey,
-        NATIVE_MINT3,
-        TOKEN_PROGRAM_ID3
+        inputMint,
+        inputTokenProgram
       )
     );
-    instructions.push(createSyncNativeInstruction3(wsolAta));
+    if (isInputWsol) {
+      instructions.push(
+        SystemProgram4.transfer({
+          fromPubkey: payerPubkey,
+          toPubkey: inputTokenAccount,
+          lamports: inputAmount
+        })
+      );
+      instructions.push(createSyncNativeInstruction3(inputTokenAccount));
+    }
   }
   if (createOutputMintAta) {
     instructions.push(
-      createAssociatedTokenAccountInstruction3(
+      createAssociatedTokenAccountIdempotentInstruction2(
         payerPubkey,
         outputTokenAccount,
         payerPubkey,
         outputMint,
-        mintTokenProgram
+        outputTokenProgram
       )
     );
   }
   const data = Buffer.alloc(24);
-  RAYDIUM_CPMM_SWAP_BASE_IN_DISCRIMINATOR.copy(data, 0);
+  (fixedOutputAmount !== void 0 ? RAYDIUM_CPMM_SWAP_BASE_OUT_DISCRIMINATOR : RAYDIUM_CPMM_SWAP_BASE_IN_DISCRIMINATOR).copy(data, 0);
   data.writeBigUInt64LE(inputAmount, 8);
-  data.writeBigUInt64LE(minimumAmountOut, 16);
+  data.writeBigUInt64LE(fixedOutputAmount ?? minimumAmountOut, 16);
   const accounts = [
     { pubkey: payerPubkey, isSigner: true, isWritable: true },
     { pubkey: RAYDIUM_CPMM_AUTHORITY, isSigner: false, isWritable: false },
@@ -2514,8 +2610,8 @@ function buildRaydiumCpmmBuyInstructions(params) {
     { pubkey: outputTokenAccount, isSigner: false, isWritable: true },
     { pubkey: inputVaultAccount, isSigner: false, isWritable: true },
     { pubkey: outputVaultAccount, isSigner: false, isWritable: true },
-    { pubkey: TOKEN_PROGRAM_ID3, isSigner: false, isWritable: false },
-    { pubkey: mintTokenProgram, isSigner: false, isWritable: false },
+    { pubkey: inputTokenProgram, isSigner: false, isWritable: false },
+    { pubkey: outputTokenProgram, isSigner: false, isWritable: false },
     { pubkey: inputMint, isSigner: false, isWritable: false },
     { pubkey: outputMint, isSigner: false, isWritable: false },
     { pubkey: observationStateAccount, isSigner: false, isWritable: true }
@@ -2527,10 +2623,9 @@ function buildRaydiumCpmmBuyInstructions(params) {
       data
     })
   );
-  if (closeInputMintAta && isWsol) {
-    const wsolAta = getAssociatedTokenAddressSync3(NATIVE_MINT3, payerPubkey, true);
+  if (closeInputMintAta && inputMint.equals(WSOL_TOKEN_ACCOUNT2)) {
     instructions.push(
-      createCloseAccountInstruction3(wsolAta, payerPubkey, payerPubkey, [], TOKEN_PROGRAM_ID3)
+      createCloseAccountInstruction3(inputTokenAccount, payerPubkey, payerPubkey, [], inputTokenProgram)
     );
   }
   return instructions;
@@ -2572,28 +2667,32 @@ function buildRaydiumCpmmSellInstructions(params) {
     throw new Error("Pool must contain WSOL or USDC");
   }
   const isQuoteOut = quoteMint.equals(WSOL_TOKEN_ACCOUNT2) || quoteMint.equals(USDC_TOKEN_ACCOUNT2);
-  const mintTokenProgram = isQuoteOut ? baseTokenProgram : quoteTokenProgram;
+  const expectedInputMint = isQuoteOut ? baseMint : quoteMint;
+  const inputTokenProgram = isQuoteOut ? baseTokenProgram : quoteTokenProgram;
+  const outputMint = isQuoteOut ? quoteMint : baseMint;
+  const outputTokenProgram = isQuoteOut ? quoteTokenProgram : baseTokenProgram;
+  if (!inputMint.equals(expectedInputMint)) {
+    throw new Error(`inputMint must match Raydium CPMM pool side ${expectedInputMint.toBase58()}`);
+  }
   const poolState = protocolParams.poolState && !protocolParams.poolState.equals(PublicKey5.default) ? protocolParams.poolState : getRaydiumCpmmPoolPda(ammConfig, baseMint, quoteMint);
-  const swapResult = computeRaydiumCpmmSwapAmount(
+  const minimumAmountOut = fixedOutputAmount ?? computeRaydiumCpmmSwapAmount(
     baseReserve,
     quoteReserve,
     isQuoteOut,
     inputAmount,
     slippageBasisPoints
-  );
-  const minimumAmountOut = fixedOutputAmount || swapResult.minAmountOut;
-  const outputMint = isWsol ? WSOL_TOKEN_ACCOUNT2 : USDC_TOKEN_ACCOUNT2;
+  ).minAmountOut;
   const inputTokenAccount = getAssociatedTokenAddressSync3(
     inputMint,
     payerPubkey,
     true,
-    mintTokenProgram
+    inputTokenProgram
   );
   const outputTokenAccount = getAssociatedTokenAddressSync3(
     outputMint,
     payerPubkey,
     true,
-    TOKEN_PROGRAM_ID3
+    outputTokenProgram
   );
   const inputVaultAccount = (() => {
     if (baseMint.equals(inputMint) && baseVault && !baseVault.equals(PublicKey5.default)) {
@@ -2605,31 +2704,30 @@ function buildRaydiumCpmmSellInstructions(params) {
     return getRaydiumCpmmVaultPda(poolState, inputMint);
   })();
   const outputVaultAccount = (() => {
-    if (isWsol && baseMint.equals(outputMint) && baseVault && !baseVault.equals(PublicKey5.default)) {
+    if (baseMint.equals(outputMint) && baseVault && !baseVault.equals(PublicKey5.default)) {
       return baseVault;
     }
-    if (!isWsol && quoteMint.equals(outputMint) && quoteVault && !quoteVault.equals(PublicKey5.default)) {
+    if (quoteMint.equals(outputMint) && quoteVault && !quoteVault.equals(PublicKey5.default)) {
       return quoteVault;
     }
     return getRaydiumCpmmVaultPda(poolState, outputMint);
   })();
   const observationStateAccount = observationState && !observationState.equals(PublicKey5.default) ? observationState : getRaydiumCpmmObservationStatePda(poolState);
-  if (createOutputMintAta && isWsol) {
-    const wsolAta = getAssociatedTokenAddressSync3(NATIVE_MINT3, payerPubkey, true);
+  if (createOutputMintAta) {
     instructions.push(
-      createAssociatedTokenAccountInstruction3(
+      createAssociatedTokenAccountIdempotentInstruction2(
         payerPubkey,
-        wsolAta,
+        outputTokenAccount,
         payerPubkey,
-        NATIVE_MINT3,
-        TOKEN_PROGRAM_ID3
+        outputMint,
+        outputTokenProgram
       )
     );
   }
   const data = Buffer.alloc(24);
-  RAYDIUM_CPMM_SWAP_BASE_IN_DISCRIMINATOR.copy(data, 0);
+  (fixedOutputAmount !== void 0 ? RAYDIUM_CPMM_SWAP_BASE_OUT_DISCRIMINATOR : RAYDIUM_CPMM_SWAP_BASE_IN_DISCRIMINATOR).copy(data, 0);
   data.writeBigUInt64LE(inputAmount, 8);
-  data.writeBigUInt64LE(minimumAmountOut, 16);
+  data.writeBigUInt64LE(fixedOutputAmount ?? minimumAmountOut, 16);
   const accounts = [
     { pubkey: payerPubkey, isSigner: true, isWritable: true },
     { pubkey: RAYDIUM_CPMM_AUTHORITY, isSigner: false, isWritable: false },
@@ -2639,8 +2737,8 @@ function buildRaydiumCpmmSellInstructions(params) {
     { pubkey: outputTokenAccount, isSigner: false, isWritable: true },
     { pubkey: inputVaultAccount, isSigner: false, isWritable: true },
     { pubkey: outputVaultAccount, isSigner: false, isWritable: true },
-    { pubkey: mintTokenProgram, isSigner: false, isWritable: false },
-    { pubkey: TOKEN_PROGRAM_ID3, isSigner: false, isWritable: false },
+    { pubkey: inputTokenProgram, isSigner: false, isWritable: false },
+    { pubkey: outputTokenProgram, isSigner: false, isWritable: false },
     { pubkey: inputMint, isSigner: false, isWritable: false },
     { pubkey: outputMint, isSigner: false, isWritable: false },
     { pubkey: observationStateAccount, isSigner: false, isWritable: true }
@@ -2652,10 +2750,9 @@ function buildRaydiumCpmmSellInstructions(params) {
       data
     })
   );
-  if (closeOutputMintAta && isWsol) {
-    const wsolAta = getAssociatedTokenAddressSync3(NATIVE_MINT3, payerPubkey, true);
+  if (closeOutputMintAta && outputMint.equals(WSOL_TOKEN_ACCOUNT2)) {
     instructions.push(
-      createCloseAccountInstruction3(wsolAta, payerPubkey, payerPubkey, [], TOKEN_PROGRAM_ID3)
+      createCloseAccountInstruction3(outputTokenAccount, payerPubkey, payerPubkey, [], outputTokenProgram)
     );
   }
   if (closeInputMintAta) {
@@ -2665,7 +2762,7 @@ function buildRaydiumCpmmSellInstructions(params) {
         payerPubkey,
         payerPubkey,
         [],
-        mintTokenProgram
+        inputTokenProgram
       )
     );
   }
@@ -2798,16 +2895,18 @@ async function getRaydiumCPMMpoolTokenBalances(connection, poolState, token0Mint
 import {
   PublicKey as PublicKey6,
   Keypair as Keypair4,
-  TransactionInstruction as TransactionInstruction5
+  TransactionInstruction as TransactionInstruction5,
+  SystemProgram as SystemProgram5
 } from "@solana/web3.js";
 import {
   getAssociatedTokenAddressSync as getAssociatedTokenAddressSync4,
-  createAssociatedTokenAccountInstruction as createAssociatedTokenAccountInstruction4,
-  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID4,
+  createAssociatedTokenAccountInstruction as createAssociatedTokenAccountInstruction2,
+  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID3,
   createCloseAccountInstruction as createCloseAccountInstruction4,
-  NATIVE_MINT as NATIVE_MINT4,
+  NATIVE_MINT as NATIVE_MINT3,
   createSyncNativeInstruction as createSyncNativeInstruction4
 } from "@solana/spl-token";
+var SOL_TOKEN_ACCOUNT3 = new PublicKey6("So11111111111111111111111111111111111111111");
 var RAYDIUM_AMM_V4_PROGRAM_ID = new PublicKey6(
   "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"
 );
@@ -2834,10 +2933,44 @@ function computeRaydiumAmmV4SwapAmount(coinReserve, pcReserve, isCoinIn, amountI
   const minAmountOut = amountOut - amountOut * slippageBasisPoints / BigInt(1e4);
   return { amountOut, minAmountOut };
 }
+function isDefaultPublicKey(pubkey) {
+  return pubkey.equals(PublicKey6.default);
+}
+function isMintMatch(requested, expected) {
+  return requested.equals(expected) || expected.equals(NATIVE_MINT3) && requested.equals(SOL_TOKEN_ACCOUNT3);
+}
+function ensureExpectedMint(label, requested, expected) {
+  if (!isDefaultPublicKey(requested) && !isMintMatch(requested, expected)) {
+    throw new Error(
+      `${label} must match the Raydium AMM v4 pool side (${expected.toBase58()}), got ${requested.toBase58()}`
+    );
+  }
+}
+function ensureMarketAccounts(params) {
+  const required = [
+    ["ammOpenOrders", params.ammOpenOrders],
+    ["ammTargetOrders", params.ammTargetOrders],
+    ["serumProgram", params.serumProgram],
+    ["serumMarket", params.serumMarket],
+    ["serumBids", params.serumBids],
+    ["serumAsks", params.serumAsks],
+    ["serumEventQueue", params.serumEventQueue],
+    ["serumCoinVaultAccount", params.serumCoinVaultAccount],
+    ["serumPcVaultAccount", params.serumPcVaultAccount],
+    ["serumVaultSigner", params.serumVaultSigner]
+  ];
+  for (const [name, account] of required) {
+    if (isDefaultPublicKey(account)) {
+      throw new Error(
+        `Raydium AMM v4 requires ${name}; pass real market accounts from the AMM/market state`
+      );
+    }
+  }
+}
 function buildRaydiumAmmV4BuyInstructions(params) {
   const {
     payer,
-    outputMint,
+    outputMint: requestedOutputMint,
     inputAmount,
     slippageBasisPoints = BigInt(1e3),
     fixedOutputAmount,
@@ -2859,9 +2992,20 @@ function buildRaydiumAmmV4BuyInstructions(params) {
     pcMint,
     tokenCoin,
     tokenPc,
+    ammOpenOrders,
+    ammTargetOrders,
+    serumProgram,
+    serumMarket,
+    serumBids,
+    serumAsks,
+    serumEventQueue,
+    serumCoinVaultAccount,
+    serumPcVaultAccount,
+    serumVaultSigner,
     coinReserve,
     pcReserve
   } = protocolParams;
+  ensureMarketAccounts(protocolParams);
   const isWsol = coinMint.equals(WSOL_TOKEN_ACCOUNT2) || pcMint.equals(WSOL_TOKEN_ACCOUNT2);
   const isUsdc = coinMint.equals(USDC_TOKEN_ACCOUNT2) || pcMint.equals(USDC_TOKEN_ACCOUNT2);
   if (!isWsol && !isUsdc) {
@@ -2875,77 +3019,88 @@ function buildRaydiumAmmV4BuyInstructions(params) {
     inputAmount,
     slippageBasisPoints
   );
-  const minimumAmountOut = fixedOutputAmount || swapResult.minAmountOut;
-  const inputMint = isWsol ? WSOL_TOKEN_ACCOUNT2 : USDC_TOKEN_ACCOUNT2;
+  const minimumAmountOut = fixedOutputAmount ?? swapResult.minAmountOut;
+  const inputMint = isBaseIn ? coinMint : pcMint;
+  const outputMint = isBaseIn ? pcMint : coinMint;
+  ensureExpectedMint("outputMint", requestedOutputMint, outputMint);
   const userSourceTokenAccount = getAssociatedTokenAddressSync4(
     inputMint,
     payerPubkey,
     true,
-    TOKEN_PROGRAM_ID4
+    TOKEN_PROGRAM_ID3
   );
   const userDestinationTokenAccount = getAssociatedTokenAddressSync4(
     outputMint,
     payerPubkey,
     true,
-    TOKEN_PROGRAM_ID4
+    TOKEN_PROGRAM_ID3
   );
-  if (createInputMintAta && isWsol) {
-    const wsolAta = getAssociatedTokenAddressSync4(NATIVE_MINT4, payerPubkey, true);
+  if (createInputMintAta && inputMint.equals(WSOL_TOKEN_ACCOUNT2)) {
+    const wsolAta = getAssociatedTokenAddressSync4(NATIVE_MINT3, payerPubkey, true);
     instructions.push(
-      createAssociatedTokenAccountInstruction4(
+      createAssociatedTokenAccountInstruction2(
         payerPubkey,
         wsolAta,
         payerPubkey,
-        NATIVE_MINT4,
-        TOKEN_PROGRAM_ID4
+        NATIVE_MINT3,
+        TOKEN_PROGRAM_ID3
       )
     );
+    instructions.push(
+      SystemProgram5.transfer({
+        fromPubkey: payerPubkey,
+        toPubkey: wsolAta,
+        lamports: Number(inputAmount)
+      })
+    );
     instructions.push(createSyncNativeInstruction4(wsolAta));
+  } else if (createInputMintAta) {
+    instructions.push(
+      createAssociatedTokenAccountInstruction2(
+        payerPubkey,
+        userSourceTokenAccount,
+        payerPubkey,
+        inputMint,
+        TOKEN_PROGRAM_ID3
+      )
+    );
   }
   if (createOutputMintAta) {
     instructions.push(
-      createAssociatedTokenAccountInstruction4(
+      createAssociatedTokenAccountInstruction2(
         payerPubkey,
         userDestinationTokenAccount,
         payerPubkey,
         outputMint,
-        TOKEN_PROGRAM_ID4
+        TOKEN_PROGRAM_ID3
       )
     );
   }
   const data = Buffer.alloc(17);
-  RAYDIUM_AMM_V4_SWAP_BASE_IN_DISCRIMINATOR.copy(data, 0);
+  (fixedOutputAmount !== void 0 ? RAYDIUM_AMM_V4_SWAP_BASE_OUT_DISCRIMINATOR : RAYDIUM_AMM_V4_SWAP_BASE_IN_DISCRIMINATOR).copy(data, 0);
   data.writeBigUInt64LE(inputAmount, 1);
   data.writeBigUInt64LE(minimumAmountOut, 9);
   const accounts = [
-    { pubkey: TOKEN_PROGRAM_ID4, isSigner: false, isWritable: false },
+    { pubkey: TOKEN_PROGRAM_ID3, isSigner: false, isWritable: false },
     { pubkey: amm, isSigner: false, isWritable: true },
     { pubkey: RAYDIUM_AMM_V4_AUTHORITY, isSigner: false, isWritable: false },
-    { pubkey: amm, isSigner: false, isWritable: true },
-    // Amm Open Orders (same as amm for simplicity)
+    { pubkey: ammOpenOrders, isSigner: false, isWritable: true },
+    { pubkey: ammTargetOrders, isSigner: false, isWritable: true },
     { pubkey: tokenCoin, isSigner: false, isWritable: true },
     // Pool Coin Token Account
     { pubkey: tokenPc, isSigner: false, isWritable: true },
     // Pool Pc Token Account
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Program (placeholder)
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Market (placeholder)
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Bids (placeholder)
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Asks (placeholder)
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Event Queue (placeholder)
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Coin Vault Account (placeholder)
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Pc Vault Account (placeholder)
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Vault Signer (placeholder)
+    { pubkey: serumProgram, isSigner: false, isWritable: false },
+    { pubkey: serumMarket, isSigner: false, isWritable: true },
+    { pubkey: serumBids, isSigner: false, isWritable: true },
+    { pubkey: serumAsks, isSigner: false, isWritable: true },
+    { pubkey: serumEventQueue, isSigner: false, isWritable: true },
+    { pubkey: serumCoinVaultAccount, isSigner: false, isWritable: true },
+    { pubkey: serumPcVaultAccount, isSigner: false, isWritable: true },
+    { pubkey: serumVaultSigner, isSigner: false, isWritable: false },
     { pubkey: userSourceTokenAccount, isSigner: false, isWritable: true },
     { pubkey: userDestinationTokenAccount, isSigner: false, isWritable: true },
-    { pubkey: payerPubkey, isSigner: true, isWritable: true }
+    { pubkey: payerPubkey, isSigner: true, isWritable: false }
   ];
   instructions.push(
     new TransactionInstruction5({
@@ -2954,10 +3109,10 @@ function buildRaydiumAmmV4BuyInstructions(params) {
       data
     })
   );
-  if (closeInputMintAta && isWsol) {
-    const wsolAta = getAssociatedTokenAddressSync4(NATIVE_MINT4, payerPubkey, true);
+  if (closeInputMintAta && inputMint.equals(WSOL_TOKEN_ACCOUNT2)) {
+    const wsolAta = getAssociatedTokenAddressSync4(NATIVE_MINT3, payerPubkey, true);
     instructions.push(
-      createCloseAccountInstruction4(wsolAta, payerPubkey, payerPubkey, [], TOKEN_PROGRAM_ID4)
+      createCloseAccountInstruction4(wsolAta, payerPubkey, payerPubkey, [], TOKEN_PROGRAM_ID3)
     );
   }
   return instructions;
@@ -2965,7 +3120,8 @@ function buildRaydiumAmmV4BuyInstructions(params) {
 function buildRaydiumAmmV4SellInstructions(params) {
   const {
     payer,
-    inputMint,
+    inputMint: requestedInputMint,
+    outputMint: requestedOutputMint,
     inputAmount,
     slippageBasisPoints = BigInt(1e3),
     fixedOutputAmount,
@@ -2987,9 +3143,20 @@ function buildRaydiumAmmV4SellInstructions(params) {
     pcMint,
     tokenCoin,
     tokenPc,
+    ammOpenOrders,
+    ammTargetOrders,
+    serumProgram,
+    serumMarket,
+    serumBids,
+    serumAsks,
+    serumEventQueue,
+    serumCoinVaultAccount,
+    serumPcVaultAccount,
+    serumVaultSigner,
     coinReserve,
     pcReserve
   } = protocolParams;
+  ensureMarketAccounts(protocolParams);
   const isWsol = coinMint.equals(WSOL_TOKEN_ACCOUNT2) || pcMint.equals(WSOL_TOKEN_ACCOUNT2);
   const isUsdc = coinMint.equals(USDC_TOKEN_ACCOUNT2) || pcMint.equals(USDC_TOKEN_ACCOUNT2);
   if (!isWsol && !isUsdc) {
@@ -3003,65 +3170,72 @@ function buildRaydiumAmmV4SellInstructions(params) {
     inputAmount,
     slippageBasisPoints
   );
-  const minimumAmountOut = fixedOutputAmount || swapResult.minAmountOut;
-  const outputMint = isWsol ? WSOL_TOKEN_ACCOUNT2 : USDC_TOKEN_ACCOUNT2;
+  const minimumAmountOut = fixedOutputAmount ?? swapResult.minAmountOut;
+  const outputMint = isBaseIn ? pcMint : coinMint;
+  const inputMint = isBaseIn ? coinMint : pcMint;
+  ensureExpectedMint("inputMint", requestedInputMint, inputMint);
+  if (requestedOutputMint) {
+    ensureExpectedMint("outputMint", requestedOutputMint, outputMint);
+  }
   const userSourceTokenAccount = getAssociatedTokenAddressSync4(
     inputMint,
     payerPubkey,
     true,
-    TOKEN_PROGRAM_ID4
+    TOKEN_PROGRAM_ID3
   );
   const userDestinationTokenAccount = getAssociatedTokenAddressSync4(
     outputMint,
     payerPubkey,
     true,
-    TOKEN_PROGRAM_ID4
+    TOKEN_PROGRAM_ID3
   );
-  if (createOutputMintAta && isWsol) {
-    const wsolAta = getAssociatedTokenAddressSync4(NATIVE_MINT4, payerPubkey, true);
+  if (createOutputMintAta && outputMint.equals(WSOL_TOKEN_ACCOUNT2)) {
+    const wsolAta = getAssociatedTokenAddressSync4(NATIVE_MINT3, payerPubkey, true);
     instructions.push(
-      createAssociatedTokenAccountInstruction4(
+      createAssociatedTokenAccountInstruction2(
         payerPubkey,
         wsolAta,
         payerPubkey,
-        NATIVE_MINT4,
-        TOKEN_PROGRAM_ID4
+        NATIVE_MINT3,
+        TOKEN_PROGRAM_ID3
+      )
+    );
+  } else if (createOutputMintAta) {
+    instructions.push(
+      createAssociatedTokenAccountInstruction2(
+        payerPubkey,
+        userDestinationTokenAccount,
+        payerPubkey,
+        outputMint,
+        TOKEN_PROGRAM_ID3
       )
     );
   }
   const data = Buffer.alloc(17);
-  RAYDIUM_AMM_V4_SWAP_BASE_IN_DISCRIMINATOR.copy(data, 0);
+  (fixedOutputAmount !== void 0 ? RAYDIUM_AMM_V4_SWAP_BASE_OUT_DISCRIMINATOR : RAYDIUM_AMM_V4_SWAP_BASE_IN_DISCRIMINATOR).copy(data, 0);
   data.writeBigUInt64LE(inputAmount, 1);
   data.writeBigUInt64LE(minimumAmountOut, 9);
   const accounts = [
-    { pubkey: TOKEN_PROGRAM_ID4, isSigner: false, isWritable: false },
+    { pubkey: TOKEN_PROGRAM_ID3, isSigner: false, isWritable: false },
     { pubkey: amm, isSigner: false, isWritable: true },
     { pubkey: RAYDIUM_AMM_V4_AUTHORITY, isSigner: false, isWritable: false },
-    { pubkey: amm, isSigner: false, isWritable: true },
-    // Amm Open Orders
+    { pubkey: ammOpenOrders, isSigner: false, isWritable: true },
+    { pubkey: ammTargetOrders, isSigner: false, isWritable: true },
     { pubkey: tokenCoin, isSigner: false, isWritable: true },
     // Pool Coin Token Account
     { pubkey: tokenPc, isSigner: false, isWritable: true },
     // Pool Pc Token Account
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Program
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Market
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Bids
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Asks
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Event Queue
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Coin Vault Account
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Pc Vault Account
-    { pubkey: amm, isSigner: false, isWritable: false },
-    // Serum Vault Signer
+    { pubkey: serumProgram, isSigner: false, isWritable: false },
+    { pubkey: serumMarket, isSigner: false, isWritable: true },
+    { pubkey: serumBids, isSigner: false, isWritable: true },
+    { pubkey: serumAsks, isSigner: false, isWritable: true },
+    { pubkey: serumEventQueue, isSigner: false, isWritable: true },
+    { pubkey: serumCoinVaultAccount, isSigner: false, isWritable: true },
+    { pubkey: serumPcVaultAccount, isSigner: false, isWritable: true },
+    { pubkey: serumVaultSigner, isSigner: false, isWritable: false },
     { pubkey: userSourceTokenAccount, isSigner: false, isWritable: true },
     { pubkey: userDestinationTokenAccount, isSigner: false, isWritable: true },
-    { pubkey: payerPubkey, isSigner: true, isWritable: true }
+    { pubkey: payerPubkey, isSigner: true, isWritable: false }
   ];
   instructions.push(
     new TransactionInstruction5({
@@ -3070,10 +3244,10 @@ function buildRaydiumAmmV4SellInstructions(params) {
       data
     })
   );
-  if (closeOutputMintAta && isWsol) {
-    const wsolAta = getAssociatedTokenAddressSync4(NATIVE_MINT4, payerPubkey, true);
+  if (closeOutputMintAta && outputMint.equals(WSOL_TOKEN_ACCOUNT2)) {
+    const wsolAta = getAssociatedTokenAddressSync4(NATIVE_MINT3, payerPubkey, true);
     instructions.push(
-      createCloseAccountInstruction4(wsolAta, payerPubkey, payerPubkey, [], TOKEN_PROGRAM_ID4)
+      createCloseAccountInstruction4(wsolAta, payerPubkey, payerPubkey, [], TOKEN_PROGRAM_ID3)
     );
   }
   if (closeInputMintAta) {
@@ -3083,13 +3257,14 @@ function buildRaydiumAmmV4SellInstructions(params) {
         payerPubkey,
         payerPubkey,
         [],
-        TOKEN_PROGRAM_ID4
+        TOKEN_PROGRAM_ID3
       )
     );
   }
   return instructions;
 }
 var AMM_INFO_SIZE = 752;
+var MARKET_STATE_SIZE = 388;
 function decodeAmmInfo(data) {
   if (data.length < AMM_INFO_SIZE) {
     return null;
@@ -3207,6 +3382,65 @@ function decodeAmmInfo(data) {
     return null;
   }
 }
+function decodeMarketState(data) {
+  if (data.length < MARKET_STATE_SIZE) {
+    return null;
+  }
+  try {
+    let offset = 5;
+    const readU64 = () => {
+      const val = data.readBigUInt64LE(offset);
+      offset += 8;
+      return val;
+    };
+    const readPubkey = () => {
+      const val = new PublicKey6(data.subarray(offset, offset + 32));
+      offset += 32;
+      return val;
+    };
+    readU64();
+    readPubkey();
+    const vaultSignerNonce = readU64();
+    readPubkey();
+    readPubkey();
+    const serumCoinVaultAccount = readPubkey();
+    readU64();
+    readU64();
+    const serumPcVaultAccount = readPubkey();
+    readU64();
+    readU64();
+    readU64();
+    readPubkey();
+    const serumEventQueue = readPubkey();
+    const serumBids = readPubkey();
+    const serumAsks = readPubkey();
+    return {
+      vaultSignerNonce,
+      serumCoinVaultAccount,
+      serumPcVaultAccount,
+      serumEventQueue,
+      serumBids,
+      serumAsks
+    };
+  } catch {
+    return null;
+  }
+}
+function deriveSerumVaultSigner(serumProgram, serumMarket, vaultSignerNonce) {
+  const nonce = Buffer.alloc(8);
+  nonce.writeBigUInt64LE(vaultSignerNonce);
+  try {
+    return PublicKey6.createProgramAddressSync(
+      [serumMarket.toBuffer(), nonce],
+      serumProgram
+    );
+  } catch {
+    return PublicKey6.createProgramAddressSync(
+      [serumMarket.toBuffer(), Buffer.from([Number(vaultSignerNonce & 0xffn)])],
+      serumProgram
+    );
+  }
+}
 async function fetchAmmInfo(connection, amm) {
   const account = await connection.getAccountInfo(amm);
   if (!account?.value?.data) {
@@ -3214,21 +3448,30 @@ async function fetchAmmInfo(connection, amm) {
   }
   return decodeAmmInfo(account.value.data);
 }
+async function fetchMarketState(connection, market) {
+  const account = await connection.getAccountInfo(market);
+  if (!account?.value?.data) {
+    return null;
+  }
+  return decodeMarketState(account.value.data);
+}
 
 // src/instruction/meteora_damm_v2_builder.ts
 import {
   PublicKey as PublicKey7,
   Keypair as Keypair5,
-  TransactionInstruction as TransactionInstruction6
+  TransactionInstruction as TransactionInstruction6,
+  SystemProgram as SystemProgram6
 } from "@solana/web3.js";
 import {
   getAssociatedTokenAddressSync as getAssociatedTokenAddressSync5,
-  createAssociatedTokenAccountInstruction as createAssociatedTokenAccountInstruction5,
-  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID5,
+  createAssociatedTokenAccountInstruction as createAssociatedTokenAccountInstruction3,
+  TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID4,
   createCloseAccountInstruction as createCloseAccountInstruction5,
-  NATIVE_MINT as NATIVE_MINT5,
+  NATIVE_MINT as NATIVE_MINT4,
   createSyncNativeInstruction as createSyncNativeInstruction5
 } from "@solana/spl-token";
+var SOL_TOKEN_ACCOUNT4 = new PublicKey7("So11111111111111111111111111111111111111111");
 var METEORA_DAMM_V2_PROGRAM_ID = new PublicKey7(
   "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"
 );
@@ -3245,6 +3488,17 @@ var METEORA_DAMM_V2_SWAP_DISCRIMINATOR = Buffer.from([
   135,
   200
 ]);
+var METEORA_DAMM_V2_SWAP2_DISCRIMINATOR = Buffer.from([
+  65,
+  75,
+  63,
+  76,
+  235,
+  91,
+  91,
+  136
+]);
+var METEORA_DAMM_V2_SWAP_MODE_PARTIAL_FILL = 1;
 var METEORA_DAMM_V2_EVENT_AUTHORITY_SEED = Buffer.from("__event_authority");
 function getMeteoraDammV2EventAuthorityPda() {
   const [pda] = PublicKey7.findProgramAddressSync(
@@ -3253,11 +3507,24 @@ function getMeteoraDammV2EventAuthorityPda() {
   );
   return pda;
 }
+function isDefaultPublicKey2(pubkey) {
+  return pubkey.equals(PublicKey7.default);
+}
+function isMintMatch2(requested, expected) {
+  return requested.equals(expected) || expected.equals(NATIVE_MINT4) && requested.equals(SOL_TOKEN_ACCOUNT4);
+}
+function ensureExpectedMint2(label, requested, expected) {
+  if (!isDefaultPublicKey2(requested) && !isMintMatch2(requested, expected)) {
+    throw new Error(
+      `${label} must match the Meteora DAMM v2 pool side (${expected.toBase58()}), got ${requested.toBase58()}`
+    );
+  }
+}
 function buildMeteoraDammV2BuyInstructions(params) {
   const {
     payer,
-    inputMint,
-    outputMint,
+    inputMint: requestedInputMint,
+    outputMint: requestedOutputMint,
     inputAmount,
     fixedOutputAmount,
     createInputMintAta = true,
@@ -3290,6 +3557,10 @@ function buildMeteoraDammV2BuyInstructions(params) {
     throw new Error("Pool must contain WSOL or USDC");
   }
   const isAIn = tokenAMint.equals(WSOL_TOKEN_ACCOUNT2) || tokenAMint.equals(USDC_TOKEN_ACCOUNT2);
+  const inputMint = isAIn ? tokenAMint : tokenBMint;
+  const outputMint = isAIn ? tokenBMint : tokenAMint;
+  ensureExpectedMint2("inputMint", requestedInputMint, inputMint);
+  ensureExpectedMint2("outputMint", requestedOutputMint, outputMint);
   const inputTokenAccount = getAssociatedTokenAddressSync5(
     inputMint,
     payerPubkey,
@@ -3303,34 +3574,54 @@ function buildMeteoraDammV2BuyInstructions(params) {
     isAIn ? tokenBProgram : tokenAProgram
   );
   const eventAuthority = getMeteoraDammV2EventAuthorityPda();
-  if (createInputMintAta && isWsol) {
-    const wsolAta = getAssociatedTokenAddressSync5(NATIVE_MINT5, payerPubkey, true);
+  const inputTokenProgram = isAIn ? tokenAProgram : tokenBProgram;
+  const outputTokenProgram = isAIn ? tokenBProgram : tokenAProgram;
+  if (createInputMintAta && inputMint.equals(WSOL_TOKEN_ACCOUNT2)) {
+    const wsolAta = getAssociatedTokenAddressSync5(NATIVE_MINT4, payerPubkey, true);
     instructions.push(
-      createAssociatedTokenAccountInstruction5(
+      createAssociatedTokenAccountInstruction3(
         payerPubkey,
         wsolAta,
         payerPubkey,
-        NATIVE_MINT5,
-        TOKEN_PROGRAM_ID5
+        NATIVE_MINT4,
+        TOKEN_PROGRAM_ID4
       )
     );
+    instructions.push(
+      SystemProgram6.transfer({
+        fromPubkey: payerPubkey,
+        toPubkey: wsolAta,
+        lamports: Number(inputAmount)
+      })
+    );
     instructions.push(createSyncNativeInstruction5(wsolAta));
+  } else if (createInputMintAta) {
+    instructions.push(
+      createAssociatedTokenAccountInstruction3(
+        payerPubkey,
+        inputTokenAccount,
+        payerPubkey,
+        inputMint,
+        inputTokenProgram
+      )
+    );
   }
   if (createOutputMintAta) {
     instructions.push(
-      createAssociatedTokenAccountInstruction5(
+      createAssociatedTokenAccountInstruction3(
         payerPubkey,
         outputTokenAccount,
         payerPubkey,
         outputMint,
-        TOKEN_PROGRAM_ID5
+        outputTokenProgram
       )
     );
   }
-  const data = Buffer.alloc(24);
-  METEORA_DAMM_V2_SWAP_DISCRIMINATOR.copy(data, 0);
+  const data = Buffer.alloc(25);
+  METEORA_DAMM_V2_SWAP2_DISCRIMINATOR.copy(data, 0);
   data.writeBigUInt64LE(inputAmount, 8);
   data.writeBigUInt64LE(fixedOutputAmount, 16);
+  data.writeUInt8(METEORA_DAMM_V2_SWAP_MODE_PARTIAL_FILL, 24);
   const accounts = [
     { pubkey: METEORA_DAMM_V2_AUTHORITY, isSigner: false, isWritable: false },
     { pubkey: pool, isSigner: false, isWritable: true },
@@ -3343,8 +3634,6 @@ function buildMeteoraDammV2BuyInstructions(params) {
     { pubkey: payerPubkey, isSigner: true, isWritable: true },
     { pubkey: tokenAProgram, isSigner: false, isWritable: false },
     { pubkey: tokenBProgram, isSigner: false, isWritable: false },
-    { pubkey: METEORA_DAMM_V2_PROGRAM_ID, isSigner: false, isWritable: false },
-    // Referral Token Account (placeholder)
     { pubkey: eventAuthority, isSigner: false, isWritable: false },
     { pubkey: METEORA_DAMM_V2_PROGRAM_ID, isSigner: false, isWritable: false }
   ];
@@ -3355,10 +3644,10 @@ function buildMeteoraDammV2BuyInstructions(params) {
       data
     })
   );
-  if (closeInputMintAta && isWsol) {
-    const wsolAta = getAssociatedTokenAddressSync5(NATIVE_MINT5, payerPubkey, true);
+  if (closeInputMintAta && inputMint.equals(WSOL_TOKEN_ACCOUNT2)) {
+    const wsolAta = getAssociatedTokenAddressSync5(NATIVE_MINT4, payerPubkey, true);
     instructions.push(
-      createCloseAccountInstruction5(wsolAta, payerPubkey, payerPubkey, [], TOKEN_PROGRAM_ID5)
+      createCloseAccountInstruction5(wsolAta, payerPubkey, payerPubkey, [], TOKEN_PROGRAM_ID4)
     );
   }
   return instructions;
@@ -3366,8 +3655,8 @@ function buildMeteoraDammV2BuyInstructions(params) {
 function buildMeteoraDammV2SellInstructions(params) {
   const {
     payer,
-    inputMint,
-    outputMint,
+    inputMint: requestedInputMint,
+    outputMint: requestedOutputMint,
     inputAmount,
     fixedOutputAmount,
     createOutputMintAta = true,
@@ -3400,6 +3689,10 @@ function buildMeteoraDammV2SellInstructions(params) {
     throw new Error("Pool must contain WSOL or USDC");
   }
   const isAIn = tokenBMint.equals(WSOL_TOKEN_ACCOUNT2) || tokenBMint.equals(USDC_TOKEN_ACCOUNT2);
+  const inputMint = isAIn ? tokenAMint : tokenBMint;
+  const outputMint = isAIn ? tokenBMint : tokenAMint;
+  ensureExpectedMint2("inputMint", requestedInputMint, inputMint);
+  ensureExpectedMint2("outputMint", requestedOutputMint, outputMint);
   const inputTokenAccount = getAssociatedTokenAddressSync5(
     inputMint,
     payerPubkey,
@@ -3413,22 +3706,35 @@ function buildMeteoraDammV2SellInstructions(params) {
     isAIn ? tokenBProgram : tokenAProgram
   );
   const eventAuthority = getMeteoraDammV2EventAuthorityPda();
-  if (createOutputMintAta && isWsol) {
-    const wsolAta = getAssociatedTokenAddressSync5(NATIVE_MINT5, payerPubkey, true);
+  const inputTokenProgram = isAIn ? tokenAProgram : tokenBProgram;
+  const outputTokenProgram = isAIn ? tokenBProgram : tokenAProgram;
+  if (createOutputMintAta && outputMint.equals(WSOL_TOKEN_ACCOUNT2)) {
+    const wsolAta = getAssociatedTokenAddressSync5(NATIVE_MINT4, payerPubkey, true);
     instructions.push(
-      createAssociatedTokenAccountInstruction5(
+      createAssociatedTokenAccountInstruction3(
         payerPubkey,
         wsolAta,
         payerPubkey,
-        NATIVE_MINT5,
-        TOKEN_PROGRAM_ID5
+        NATIVE_MINT4,
+        TOKEN_PROGRAM_ID4
+      )
+    );
+  } else if (createOutputMintAta) {
+    instructions.push(
+      createAssociatedTokenAccountInstruction3(
+        payerPubkey,
+        outputTokenAccount,
+        payerPubkey,
+        outputMint,
+        outputTokenProgram
       )
     );
   }
-  const data = Buffer.alloc(24);
-  METEORA_DAMM_V2_SWAP_DISCRIMINATOR.copy(data, 0);
+  const data = Buffer.alloc(25);
+  METEORA_DAMM_V2_SWAP2_DISCRIMINATOR.copy(data, 0);
   data.writeBigUInt64LE(inputAmount, 8);
   data.writeBigUInt64LE(fixedOutputAmount, 16);
+  data.writeUInt8(METEORA_DAMM_V2_SWAP_MODE_PARTIAL_FILL, 24);
   const accounts = [
     { pubkey: METEORA_DAMM_V2_AUTHORITY, isSigner: false, isWritable: false },
     { pubkey: pool, isSigner: false, isWritable: true },
@@ -3441,8 +3747,6 @@ function buildMeteoraDammV2SellInstructions(params) {
     { pubkey: payerPubkey, isSigner: true, isWritable: true },
     { pubkey: tokenAProgram, isSigner: false, isWritable: false },
     { pubkey: tokenBProgram, isSigner: false, isWritable: false },
-    { pubkey: METEORA_DAMM_V2_PROGRAM_ID, isSigner: false, isWritable: false },
-    // Referral Token Account
     { pubkey: eventAuthority, isSigner: false, isWritable: false },
     { pubkey: METEORA_DAMM_V2_PROGRAM_ID, isSigner: false, isWritable: false }
   ];
@@ -3453,10 +3757,10 @@ function buildMeteoraDammV2SellInstructions(params) {
       data
     })
   );
-  if (closeOutputMintAta && isWsol) {
-    const wsolAta = getAssociatedTokenAddressSync5(NATIVE_MINT5, payerPubkey, true);
+  if (closeOutputMintAta && outputMint.equals(WSOL_TOKEN_ACCOUNT2)) {
+    const wsolAta = getAssociatedTokenAddressSync5(NATIVE_MINT4, payerPubkey, true);
     instructions.push(
-      createCloseAccountInstruction5(wsolAta, payerPubkey, payerPubkey, [], TOKEN_PROGRAM_ID5)
+      createCloseAccountInstruction5(wsolAta, payerPubkey, payerPubkey, [], TOKEN_PROGRAM_ID4)
     );
   }
   if (closeInputMintAta) {
@@ -3541,14 +3845,14 @@ import {
   SystemProgram as SystemProgram7,
   SYSVAR_RENT_PUBKEY as SYSVAR_RENT_PUBKEY2
 } from "@solana/web3.js";
-var TOKEN_PROGRAM_ID6 = new PublicKey8("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+var TOKEN_PROGRAM_ID5 = new PublicKey8("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
 var TOKEN_2022_PROGRAM_ID2 = new PublicKey8("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
 var ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey8("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
 var TokenInstructionBuilder = class {
   /**
    * Create InitializeMint instruction
    */
-  static initializeMint(mint, decimals, mintAuthority, freezeAuthority, tokenProgram = TOKEN_PROGRAM_ID6) {
+  static initializeMint(mint, decimals, mintAuthority, freezeAuthority, tokenProgram = TOKEN_PROGRAM_ID5) {
     const keys = [
       { pubkey: mint, isSigner: false, isWritable: true },
       { pubkey: SYSVAR_RENT_PUBKEY2, isSigner: false, isWritable: false }
@@ -3571,7 +3875,7 @@ var TokenInstructionBuilder = class {
   /**
    * Create InitializeAccount instruction
    */
-  static initializeAccount(account, mint, owner, tokenProgram = TOKEN_PROGRAM_ID6) {
+  static initializeAccount(account, mint, owner, tokenProgram = TOKEN_PROGRAM_ID5) {
     const keys = [
       { pubkey: account, isSigner: false, isWritable: true },
       { pubkey: mint, isSigner: false, isWritable: false },
@@ -3588,7 +3892,7 @@ var TokenInstructionBuilder = class {
   /**
    * Create Transfer instruction
    */
-  static transfer(source, destination, owner, amount, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID6) {
+  static transfer(source, destination, owner, amount, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID5) {
     const keys = [
       { pubkey: source, isSigner: false, isWritable: true },
       { pubkey: destination, isSigner: false, isWritable: true },
@@ -3611,7 +3915,7 @@ var TokenInstructionBuilder = class {
   /**
    * Create TransferChecked instruction
    */
-  static transferChecked(source, mint, destination, owner, amount, decimals, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID6) {
+  static transferChecked(source, mint, destination, owner, amount, decimals, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID5) {
     const keys = [
       { pubkey: source, isSigner: false, isWritable: true },
       { pubkey: mint, isSigner: false, isWritable: false },
@@ -3636,7 +3940,7 @@ var TokenInstructionBuilder = class {
   /**
    * Create MintTo instruction
    */
-  static mintTo(mint, destination, authority, amount, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID6) {
+  static mintTo(mint, destination, authority, amount, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID5) {
     const keys = [
       { pubkey: mint, isSigner: false, isWritable: true },
       { pubkey: destination, isSigner: false, isWritable: true },
@@ -3659,7 +3963,7 @@ var TokenInstructionBuilder = class {
   /**
    * Create Burn instruction
    */
-  static burn(account, mint, owner, amount, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID6) {
+  static burn(account, mint, owner, amount, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID5) {
     const keys = [
       { pubkey: account, isSigner: false, isWritable: true },
       { pubkey: mint, isSigner: false, isWritable: true },
@@ -3682,7 +3986,7 @@ var TokenInstructionBuilder = class {
   /**
    * Create Approve instruction
    */
-  static approve(account, delegate, owner, amount, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID6) {
+  static approve(account, delegate, owner, amount, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID5) {
     const keys = [
       { pubkey: account, isSigner: false, isWritable: true },
       { pubkey: delegate, isSigner: false, isWritable: false },
@@ -3705,7 +4009,7 @@ var TokenInstructionBuilder = class {
   /**
    * Create Revoke instruction
    */
-  static revoke(account, owner, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID6) {
+  static revoke(account, owner, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID5) {
     const keys = [
       { pubkey: account, isSigner: false, isWritable: true },
       { pubkey: owner, isSigner: multiSigners.length === 0, isWritable: false },
@@ -3725,7 +4029,7 @@ var TokenInstructionBuilder = class {
   /**
    * Create CloseAccount instruction
    */
-  static closeAccount(account, destination, owner, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID6) {
+  static closeAccount(account, destination, owner, multiSigners = [], tokenProgram = TOKEN_PROGRAM_ID5) {
     const keys = [
       { pubkey: account, isSigner: false, isWritable: true },
       { pubkey: destination, isSigner: false, isWritable: true },
@@ -3746,7 +4050,7 @@ var TokenInstructionBuilder = class {
   /**
    * Create SyncNative instruction (for WSOL accounts)
    */
-  static syncNative(nativeAccount, tokenProgram = TOKEN_PROGRAM_ID6) {
+  static syncNative(nativeAccount, tokenProgram = TOKEN_PROGRAM_ID5) {
     const keys = [{ pubkey: nativeAccount, isSigner: false, isWritable: true }];
     const data = Buffer.from([17 /* SyncNative */]);
     return new TransactionInstruction7({
@@ -3760,7 +4064,7 @@ var TokenUtil = class {
   /**
    * Calculate associated token account address
    */
-  static async getAssociatedTokenAddress(mint, owner, _allowOwnerOffCurve = false, tokenProgram = TOKEN_PROGRAM_ID6, associatedTokenProgram = ASSOCIATED_TOKEN_PROGRAM_ID) {
+  static async getAssociatedTokenAddress(mint, owner, _allowOwnerOffCurve = false, tokenProgram = TOKEN_PROGRAM_ID5, associatedTokenProgram = ASSOCIATED_TOKEN_PROGRAM_ID) {
     const [address] = await PublicKey8.findProgramAddress(
       [owner.toBuffer(), tokenProgram.toBuffer(), mint.toBuffer()],
       associatedTokenProgram
@@ -3770,7 +4074,7 @@ var TokenUtil = class {
   /**
    * Create associated token account idempotent instruction
    */
-  static createAssociatedTokenAccountIdempotentInstruction(payer, associatedToken, owner, mint, tokenProgram = TOKEN_PROGRAM_ID6, associatedTokenProgram = ASSOCIATED_TOKEN_PROGRAM_ID) {
+  static createAssociatedTokenAccountIdempotentInstruction(payer, associatedToken, owner, mint, tokenProgram = TOKEN_PROGRAM_ID5, associatedTokenProgram = ASSOCIATED_TOKEN_PROGRAM_ID) {
     const keys = [
       { pubkey: payer, isSigner: true, isWritable: true },
       { pubkey: associatedToken, isSigner: false, isWritable: true },
@@ -3790,7 +4094,7 @@ var TokenUtil = class {
   /**
    * Create associated token account instruction
    */
-  static createAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, tokenProgram = TOKEN_PROGRAM_ID6, associatedTokenProgram = ASSOCIATED_TOKEN_PROGRAM_ID) {
+  static createAssociatedTokenAccountInstruction(payer, associatedToken, owner, mint, tokenProgram = TOKEN_PROGRAM_ID5, associatedTokenProgram = ASSOCIATED_TOKEN_PROGRAM_ID) {
     const keys = [
       { pubkey: payer, isSigner: true, isWritable: true },
       { pubkey: associatedToken, isSigner: false, isWritable: true },
@@ -3836,7 +4140,7 @@ var TokenUtil = class {
   }
 };
 var WSOL_MINT2 = new PublicKey8("So11111111111111111111111111111111111111112");
-var NATIVE_MINT6 = new PublicKey8("So11111111111111111111111111111111111111111");
+var NATIVE_MINT5 = new PublicKey8("So11111111111111111111111111111111111111111");
 var USDC_MINT2 = new PublicKey8("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
 var USDT_MINT = new PublicKey8("Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB");
 
@@ -4075,23 +4379,6 @@ async function confirmAnyTransactionSignature(connection, signatures, options) {
   );
 }
 
-// src/common/map-pool.ts
-async function mapWithConcurrencyLimit(items, concurrency, fn) {
-  if (items.length === 0) return [];
-  const limit = Math.max(1, Math.min(concurrency, items.length));
-  const results = new Array(items.length);
-  let next = 0;
-  const worker = async () => {
-    for (; ; ) {
-      const i = next++;
-      if (i >= items.length) return;
-      results[i] = await fn(items[i], i);
-    }
-  };
-  await Promise.all(Array.from({ length: limit }, () => worker()));
-  return results;
-}
-
 // src/execution/execution.ts
 var BYTES_PER_ACCOUNT = 32;
 var MAX_INSTRUCTIONS_WARN = 64;
@@ -4517,12 +4804,22 @@ var RaydiumCpmmParams = class _RaydiumCpmmParams {
   }
 };
 var RaydiumAmmV4Params = class _RaydiumAmmV4Params {
-  constructor(amm, coinMint, pcMint, tokenCoin, tokenPc, coinReserve, pcReserve) {
+  constructor(amm, coinMint, pcMint, tokenCoin, tokenPc, ammOpenOrders, ammTargetOrders, serumProgram, serumMarket, serumBids, serumAsks, serumEventQueue, serumCoinVaultAccount, serumPcVaultAccount, serumVaultSigner, coinReserve, pcReserve) {
     this.amm = amm;
     this.coinMint = coinMint;
     this.pcMint = pcMint;
     this.tokenCoin = tokenCoin;
     this.tokenPc = tokenPc;
+    this.ammOpenOrders = ammOpenOrders;
+    this.ammTargetOrders = ammTargetOrders;
+    this.serumProgram = serumProgram;
+    this.serumMarket = serumMarket;
+    this.serumBids = serumBids;
+    this.serumAsks = serumAsks;
+    this.serumEventQueue = serumEventQueue;
+    this.serumCoinVaultAccount = serumCoinVaultAccount;
+    this.serumPcVaultAccount = serumPcVaultAccount;
+    this.serumVaultSigner = serumVaultSigner;
     this.coinReserve = coinReserve;
     this.pcReserve = pcReserve;
   }
@@ -4531,6 +4828,16 @@ var RaydiumAmmV4Params = class _RaydiumAmmV4Params {
   pcMint;
   tokenCoin;
   tokenPc;
+  ammOpenOrders;
+  ammTargetOrders;
+  serumProgram;
+  serumMarket;
+  serumBids;
+  serumAsks;
+  serumEventQueue;
+  serumCoinVaultAccount;
+  serumPcVaultAccount;
+  serumVaultSigner;
   coinReserve;
   pcReserve;
   static async fromAmmAddressByRpc(connection, amm) {
@@ -4538,16 +4845,35 @@ var RaydiumAmmV4Params = class _RaydiumAmmV4Params {
     if (!ammInfo) {
       throw new Error("Raydium AMM account not found");
     }
+    const marketState = await fetchMarketState(wrapConnection(connection), ammInfo.market);
+    if (!marketState) {
+      throw new Error("Raydium AMM market account not found");
+    }
+    const serumVaultSigner = deriveSerumVaultSigner(
+      ammInfo.serumDex,
+      ammInfo.market,
+      marketState.vaultSignerNonce
+    );
     const coinBal = await connection.getTokenAccountBalance(ammInfo.tokenCoin);
     const pcBal = await connection.getTokenAccountBalance(ammInfo.tokenPc);
-    const coinReserve = Number(coinBal.value.amount);
-    const pcReserve = Number(pcBal.value.amount);
+    const coinReserve = BigInt(coinBal.value.amount);
+    const pcReserve = BigInt(pcBal.value.amount);
     return new _RaydiumAmmV4Params(
       amm,
       ammInfo.coinMint,
       ammInfo.pcMint,
       ammInfo.tokenCoin,
       ammInfo.tokenPc,
+      ammInfo.openOrders,
+      ammInfo.targetOrders,
+      ammInfo.serumDex,
+      ammInfo.market,
+      marketState.serumBids,
+      marketState.serumAsks,
+      marketState.serumEventQueue,
+      marketState.serumCoinVaultAccount,
+      marketState.serumPcVaultAccount,
+      serumVaultSigner,
       coinReserve,
       pcReserve
     );
@@ -5148,20 +5474,30 @@ var HotPathExecutor = class {
       }
     };
     const promises = clients.map(submitToClient);
-    try {
-      const result = await Promise.any(promises);
-      return result;
-    } catch {
-      const results = await Promise.allSettled(promises);
-      const errors = results.filter((r) => r.status === "rejected").map((r) => r.reason);
-      return {
-        signature: "",
-        success: false,
-        error: `All parallel submissions failed: ${errors.join(", ")}`,
-        latencyMs: 0,
-        blockhashUsed: ""
-      };
+    const pending = new Map(
+      promises.map((promise, index) => [
+        index,
+        promise.then((result) => ({ index, result }))
+      ])
+    );
+    const errors = [];
+    while (pending.size > 0) {
+      const { index, result } = await Promise.race(pending.values());
+      pending.delete(index);
+      if (result.success) {
+        return result;
+      }
+      if (result.error) {
+        errors.push(`${result.swqosType ?? "unknown"}: ${result.error}`);
+      }
     }
+    return {
+      signature: "",
+      success: false,
+      error: `All parallel submissions failed${errors.length ? `: ${errors.join(", ")}` : ""}`,
+      latencyMs: 0,
+      blockhashUsed: ""
+    };
   }
   /**
    * Submit to SWQoS clients sequentially - NO RPC
@@ -5253,6 +5589,23 @@ function createHotPathExecutor(connection, swqosClients, config) {
   return executor;
 }
 
+// src/common/map-pool.ts
+async function mapWithConcurrencyLimit(items, concurrency, fn) {
+  if (items.length === 0) return [];
+  const limit = Math.max(1, Math.min(concurrency, items.length));
+  const results = new Array(items.length);
+  let next = 0;
+  const worker = async () => {
+    for (; ; ) {
+      const i = next++;
+      if (i >= items.length) return;
+      results[i] = await fn(items[i], i);
+    }
+  };
+  await Promise.all(Array.from({ length: limit }, () => worker()));
+  return results;
+}
+
 // src/common/nonce.ts
 import { PublicKey as PublicKey15 } from "@solana/web3.js";
 import bs58 from "bs58";
@@ -5790,6 +6143,22 @@ var AddressLookupTableCache = class {
 var addressLookupTableCache = new AddressLookupTableCache();
 
 // src/trading/factory.ts
+var DexType = /* @__PURE__ */ ((DexType3) => {
+  DexType3["PumpFun"] = "PumpFun";
+  DexType3["PumpSwap"] = "PumpSwap";
+  DexType3["Bonk"] = "Bonk";
+  DexType3["RaydiumCpmm"] = "RaydiumCpmm";
+  DexType3["RaydiumAmmV4"] = "RaydiumAmmV4";
+  DexType3["MeteoraDammV2"] = "MeteoraDammV2";
+  return DexType3;
+})(DexType || {});
+var TradeType = /* @__PURE__ */ ((TradeType4) => {
+  TradeType4["Buy"] = "Buy";
+  TradeType4["Sell"] = "Sell";
+  TradeType4["Create"] = "Create";
+  TradeType4["CreateAndBuy"] = "CreateAndBuy";
+  return TradeType4;
+})(TradeType || {});
 function defaultTradeExecuteOptions() {
   return {
     waitConfirmation: true,
@@ -6138,15 +6507,15 @@ function withAllBuiltinMiddlewares() {
 }
 
 // src/index.ts
-var DexType = /* @__PURE__ */ ((DexType2) => {
-  DexType2["PumpFun"] = "PumpFun";
-  DexType2["PumpSwap"] = "PumpSwap";
-  DexType2["Bonk"] = "Bonk";
-  DexType2["RaydiumCpmm"] = "RaydiumCpmm";
-  DexType2["RaydiumAmmV4"] = "RaydiumAmmV4";
-  DexType2["MeteoraDammV2"] = "MeteoraDammV2";
-  return DexType2;
-})(DexType || {});
+var DexType2 = /* @__PURE__ */ ((DexType3) => {
+  DexType3["PumpFun"] = "PumpFun";
+  DexType3["PumpSwap"] = "PumpSwap";
+  DexType3["Bonk"] = "Bonk";
+  DexType3["RaydiumCpmm"] = "RaydiumCpmm";
+  DexType3["RaydiumAmmV4"] = "RaydiumAmmV4";
+  DexType3["MeteoraDammV2"] = "MeteoraDammV2";
+  return DexType3;
+})(DexType2 || {});
 var TradeTokenType = /* @__PURE__ */ ((TradeTokenType2) => {
   TradeTokenType2["SOL"] = "SOL";
   TradeTokenType2["WSOL"] = "WSOL";
@@ -6154,11 +6523,11 @@ var TradeTokenType = /* @__PURE__ */ ((TradeTokenType2) => {
   TradeTokenType2["USDC"] = "USDC";
   return TradeTokenType2;
 })(TradeTokenType || {});
-var TradeType2 = /* @__PURE__ */ ((TradeType3) => {
-  TradeType3["Buy"] = "Buy";
-  TradeType3["Sell"] = "Sell";
-  return TradeType3;
-})(TradeType2 || {});
+var TradeType3 = /* @__PURE__ */ ((TradeType4) => {
+  TradeType4["Buy"] = "Buy";
+  TradeType4["Sell"] = "Sell";
+  return TradeType4;
+})(TradeType3 || {});
 var SwqosRegion = /* @__PURE__ */ ((SwqosRegion2) => {
   SwqosRegion2["Frankfurt"] = "Frankfurt";
   SwqosRegion2["NewYork"] = "NewYork";
@@ -6207,6 +6576,88 @@ var AstralaneTransport = /* @__PURE__ */ ((AstralaneTransport2) => {
   AstralaneTransport2["Quic"] = "Quic";
   return AstralaneTransport2;
 })(AstralaneTransport || {});
+function normalizeSwqosConfigs(rpcUrl, configs) {
+  if (configs.length === 0 || configs.some((c) => c.type === "Default" /* Default */)) {
+    return configs;
+  }
+  return [
+    ...configs,
+    {
+      type: "Default" /* Default */,
+      region: "Default" /* Default */,
+      apiKey: "",
+      customUrl: rpcUrl
+    }
+  ];
+}
+function parserPublicKey(value) {
+  if (!value) return PublicKey20.default;
+  if (value instanceof PublicKey20) return value;
+  if (value === PublicKey20.default.toBase58()) return PublicKey20.default;
+  return new PublicKey20(value);
+}
+function pumpFunQuoteMintForLayout(quoteMint) {
+  if (quoteMint.equals(PublicKey20.default) || quoteMint.equals(CONSTANTS.SOL_TOKEN_ACCOUNT)) {
+    return PublicKey20.default;
+  }
+  return quoteMint;
+}
+function parserU64(value) {
+  if (value === void 0 || value === null || value === "") return 0;
+  const n = typeof value === "bigint" ? value : BigInt(value);
+  if (n > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new TradeError(106, `parser u64 value ${n.toString()} exceeds JavaScript safe integer range`);
+  }
+  return Number(n);
+}
+function pumpFunParamsFromParserTrade(event, closeTokenAccountWhenSell) {
+  const quoteMint = parserPublicKey(event.quote_mint);
+  const legacySolQuote = quoteMint.equals(PublicKey20.default) || quoteMint.equals(CONSTANTS.SOL_TOKEN_ACCOUNT);
+  const hasVirtualQuote = event.virtual_quote_reserves !== void 0;
+  const hasRealQuote = event.real_quote_reserves !== void 0;
+  const virtualQuote = !legacySolQuote && hasVirtualQuote ? parserU64(event.virtual_quote_reserves) : parserU64(event.virtual_sol_reserves);
+  const realQuote = !legacySolQuote && hasRealQuote ? parserU64(event.real_quote_reserves) : parserU64(event.real_sol_reserves);
+  const creator = parserPublicKey(event.creator);
+  return {
+    bondingCurve: {
+      discriminator: 0,
+      account: parserPublicKey(event.bonding_curve),
+      virtualTokenReserves: parserU64(event.virtual_token_reserves),
+      virtualSolReserves: virtualQuote,
+      realTokenReserves: parserU64(event.real_token_reserves),
+      realSolReserves: realQuote,
+      tokenTotalSupply: 0,
+      complete: false,
+      creator,
+      isMayhemMode: !!event.mayhem_mode,
+      isCashbackCoin: !!event.is_cashback_coin
+    },
+    associatedBondingCurve: parserPublicKey(event.associated_bonding_curve),
+    creatorVault: parserPublicKey(event.creator_vault),
+    tokenProgram: parserPublicKey(event.token_program),
+    closeTokenAccountWhenSell,
+    feeRecipient: parserPublicKey(event.fee_recipient),
+    quoteMint: pumpFunQuoteMintForLayout(quoteMint),
+    observedTradeCreator: creator.equals(PublicKey20.default) ? void 0 : creator
+  };
+}
+function pumpSwapParamsFromParserTrade(event) {
+  return {
+    pool: parserPublicKey(event.pool),
+    baseMint: parserPublicKey(event.base_mint),
+    quoteMint: parserPublicKey(event.quote_mint),
+    poolBaseTokenAccount: parserPublicKey(event.pool_base_token_account),
+    poolQuoteTokenAccount: parserPublicKey(event.pool_quote_token_account),
+    poolBaseTokenReserves: parserU64(event.pool_base_token_reserves),
+    poolQuoteTokenReserves: parserU64(event.pool_quote_token_reserves),
+    coinCreatorVaultAta: parserPublicKey(event.coin_creator_vault_ata),
+    coinCreatorVaultAuthority: parserPublicKey(event.coin_creator_vault_authority),
+    baseTokenProgram: parserPublicKey(event.base_token_program),
+    quoteTokenProgram: parserPublicKey(event.quote_token_program),
+    isMayhemMode: !!event.is_mayhem_mode,
+    isCashbackCoin: !!event.is_cashback_coin
+  };
+}
 var TradeConfigBuilder = class _TradeConfigBuilder {
   _rpcUrl;
   _swqosConfigs = [];
@@ -6215,7 +6666,6 @@ var TradeConfigBuilder = class _TradeConfigBuilder {
   _checkMinTip = false;
   _mevProtection = false;
   _useSeedOptimize = true;
-  _usePumpfunV2 = false;
   _swqosCoresFromEnd = true;
   _createWsolAtaOnStartup = false;
   _gasFeeStrategy;
@@ -6229,7 +6679,7 @@ var TradeConfigBuilder = class _TradeConfigBuilder {
     return new _TradeConfigBuilder(rpcUrl);
   }
   swqosConfigs(configs) {
-    this._swqosConfigs = configs;
+    this._swqosConfigs = normalizeSwqosConfigs(this._rpcUrl, configs);
     return this;
   }
   commitment(commitment) {
@@ -6258,10 +6708,6 @@ var TradeConfigBuilder = class _TradeConfigBuilder {
     this._useSeedOptimize = enabled;
     return this;
   }
-  usePumpfunV2(enabled) {
-    this._usePumpfunV2 = enabled;
-    return this;
-  }
   swqosCoresFromEnd(enabled) {
     this._swqosCoresFromEnd = enabled;
     return this;
@@ -6293,13 +6739,12 @@ var TradeConfigBuilder = class _TradeConfigBuilder {
   build() {
     return {
       rpcUrl: this._rpcUrl,
-      swqosConfigs: this._swqosConfigs,
+      swqosConfigs: normalizeSwqosConfigs(this._rpcUrl, this._swqosConfigs),
       commitment: this._commitment,
       logEnabled: this._logEnabled,
       checkMinTip: this._checkMinTip,
       mevProtection: this._mevProtection,
       useSeedOptimize: this._useSeedOptimize,
-      usePumpfunV2: this._usePumpfunV2,
       swqosCoresFromEnd: this._swqosCoresFromEnd,
       createWsolAtaOnStartup: this._createWsolAtaOnStartup,
       gasFeeStrategy: this._gasFeeStrategy,
@@ -6346,8 +6791,7 @@ function mapPumpFunParams(p) {
     feeSharingCreatorVaultIfActive: p.feeSharingCreatorVaultIfActive,
     closeTokenAccountWhenSell: p.closeTokenAccountWhenSell,
     feeRecipient: p.feeRecipient,
-    quoteMint: p.quoteMint,
-    useV2Ix: p.useV2Ix
+    quoteMint: p.quoteMint
   };
 }
 async function findPoolByMint2(connection, mint, dexType) {
@@ -6371,7 +6815,7 @@ async function findPoolByMint2(connection, mint, dexType) {
   }
   return found.poolAddress;
 }
-var SWQOS_SUBMIT_TIMEOUT_MS_WHEN_NO_CONFIRM = 2e3;
+var SWQOS_SUBMIT_TIMEOUT_MS_WHEN_NO_CONFIRM = 5e3;
 var RUST_PARITY_SIMULATE_CONFIG = {
   sigVerify: false,
   replaceRecentBlockhash: false,
@@ -6448,7 +6892,24 @@ function gasConfigFromStrategyValue(value, tradeType) {
     sellTipLamports: !isBuy ? tipLam : 0
   };
 }
-function expandSwqosGasTasks(effectiveSwqos, tradeType, execGas, configGas, gasStrategy, useStrategyRowMinTip, checkMinTip, withTip, swqosMod, mevProtection, rpcUrl, logEnabled) {
+async function collectUntilFirstSuccess(promises, isSuccess) {
+  if (promises.length === 0) return [];
+  const results = [];
+  const pending = new Map(
+    promises.map((promise, index) => [
+      index,
+      promise.then((result) => ({ index, result }))
+    ])
+  );
+  while (pending.size > 0) {
+    const { index, result } = await Promise.race(pending.values());
+    pending.delete(index);
+    results.push(result);
+    if (isSuccess(result)) return results;
+  }
+  return results;
+}
+function expandSwqosGasTasks(effectiveSwqos, tradeType, execGas, configGas, gasStrategy, useStrategyRowMinTip, checkMinTip, withTip, swqosMod, mevProtection, rpcUrl, logEnabled, getClient) {
   const out = [];
   if (execGas || configGas) {
     for (const cfg of effectiveSwqos) {
@@ -6473,10 +6934,7 @@ function expandSwqosGasTasks(effectiveSwqos, tradeType, execGas, configGas, gasS
       for (const row of matching) {
         const tipLamports = Math.floor(row.value.tip * 1e9);
         if (checkMinTip && withTip && cfg.type !== "Default" /* Default */) {
-          const client = swqosMod.ClientFactory.createClient(
-            mapSwqosToClientConfig(cfg, mevProtection),
-            rpcUrl
-          );
+          const client = getClient?.(cfg) ?? swqosMod.ClientFactory.createClient(mapSwqosToClientConfig(cfg, mevProtection), rpcUrl);
           const minLamports = Math.ceil(client.minTipSol() * 1e9);
           if (tipLamports < minLamports) {
             if (logEnabled) {
@@ -6514,7 +6972,7 @@ function filterSwqosConfigsForWithTip(configs, withTip) {
   if (withTip) return configs;
   return configs.filter((c) => c.type === "Default" /* Default */);
 }
-function filterSwqosConfigsByMinTip(swqosMod, configs, tradeType, gas, mevProtection, rpcUrl, logEnabled) {
+function filterSwqosConfigsByMinTip(swqosMod, configs, tradeType, gas, mevProtection, rpcUrl, logEnabled, getClient) {
   const tipLamports = gas ? tradeType === "Buy" /* Buy */ ? gas.buyTipLamports : gas.sellTipLamports : 0;
   const out = [];
   for (const cfg of configs) {
@@ -6522,10 +6980,7 @@ function filterSwqosConfigsByMinTip(swqosMod, configs, tradeType, gas, mevProtec
       out.push(cfg);
       continue;
     }
-    const client = swqosMod.ClientFactory.createClient(
-      mapSwqosToClientConfig(cfg, mevProtection),
-      rpcUrl
-    );
+    const client = getClient?.(cfg) ?? swqosMod.ClientFactory.createClient(mapSwqosToClientConfig(cfg, mevProtection), rpcUrl);
     const minLamports = Math.ceil(client.minTipSol() * 1e9);
     if (tipLamports < minLamports) {
       if (logEnabled) {
@@ -6539,13 +6994,10 @@ function filterSwqosConfigsByMinTip(swqosMod, configs, tradeType, gas, mevProtec
   }
   return out;
 }
-function resolveTipRecipientPubkey(swqosMod, configs, mevProtection, rpcUrl) {
+function resolveTipRecipientPubkey(swqosMod, configs, mevProtection, rpcUrl, getClient) {
   const preferred = configs.find((c) => c.type !== "Default" /* Default */) ?? configs[0];
   if (!preferred) return null;
-  const client = swqosMod.ClientFactory.createClient(
-    mapSwqosToClientConfig(preferred, mevProtection),
-    rpcUrl
-  );
+  const client = getClient?.(preferred) ?? swqosMod.ClientFactory.createClient(mapSwqosToClientConfig(preferred, mevProtection), rpcUrl);
   const acc = client.getTipAccount();
   if (!acc) return null;
   try {
@@ -6560,14 +7012,48 @@ var TradingClient = class {
   _config;
   middlewares = [];
   _logEnabled;
+  _swqosModulePromise;
+  _swqosClientCache = /* @__PURE__ */ new Map();
   constructor(payer, config) {
     this.payer = payer;
-    this._config = config;
+    this._config = {
+      ...config,
+      swqosConfigs: normalizeSwqosConfigs(config.rpcUrl, config.swqosConfigs ?? [])
+    };
     this.connection = new Connection6(config.rpcUrl, {
       commitment: config.commitment ?? "confirmed"
     });
     this._logEnabled = config.logEnabled ?? true;
   }
+  getSwqosModule() {
+    this._swqosModulePromise ??= import("./clients-PSG35HN4.mjs");
+    return this._swqosModulePromise;
+  }
+  swqosClientCacheKey(cfg) {
+    return JSON.stringify([
+      this._config.rpcUrl,
+      this._config.mevProtection ?? false,
+      cfg.type,
+      cfg.region ?? null,
+      cfg.customUrl ?? null,
+      cfg.apiKey ?? null,
+      cfg.transport ?? null,
+      cfg.astralaneTransport ?? null,
+      cfg.swqosOnly ?? null,
+      cfg.mevProtection ?? null
+    ]);
+  }
+  getSwqosClient(swqosMod, cfg) {
+    const key = this.swqosClientCacheKey(cfg);
+    const cached = this._swqosClientCache.get(key);
+    if (cached) return cached;
+    const client = swqosMod.ClientFactory.createClient(
+      mapSwqosToClientConfig(cfg, this._config.mevProtection),
+      this._config.rpcUrl
+    );
+    this._swqosClientCache.set(key, client);
+    return client;
+  }
   /** Get the current configuration */
   get config() {
     return this._config;
@@ -6802,9 +7288,10 @@ var TradingClient = class {
           fixedOutputAmount: params.fixedOutputTokenAmount !== void 0 ? BigInt(params.fixedOutputTokenAmount) : void 0,
           createOutputMintAta: params.createMintAta ?? true,
           createInputMintAta: params.createInputTokenAta ?? false,
+          closeInputMintAta: params.closeInputTokenAta ?? false,
           protocolParams: mapPumpFunParams(ext.params),
           useExactSolAmount: params.useExactSolAmount ?? true,
-          usePumpFunV2: this._config.usePumpfunV2 ?? ext.params.useV2Ix ?? false
+          inputMint: this.getInputMint(params.inputTokenType)
         });
       }
       case "PumpSwap" /* PumpSwap */: {
@@ -6903,8 +7390,18 @@ var TradingClient = class {
           pcMint: p.pcMint,
           tokenCoin: p.tokenCoin,
           tokenPc: p.tokenPc,
-          coinReserve: BigInt(p.coinReserve),
-          pcReserve: BigInt(p.pcReserve)
+          ammOpenOrders: p.ammOpenOrders,
+          ammTargetOrders: p.ammTargetOrders,
+          serumProgram: p.serumProgram,
+          serumMarket: p.serumMarket,
+          serumBids: p.serumBids,
+          serumAsks: p.serumAsks,
+          serumEventQueue: p.serumEventQueue,
+          serumCoinVaultAccount: p.serumCoinVaultAccount,
+          serumPcVaultAccount: p.serumPcVaultAccount,
+          serumVaultSigner: p.serumVaultSigner,
+          coinReserve: p.coinReserve,
+          pcReserve: p.pcReserve
         };
         return buildRaydiumAmmV4BuyInstructions({
           payer: this.payer.publicKey,
@@ -6970,7 +7467,7 @@ var TradingClient = class {
           closeInputMintAta: params.closeMintTokenAta ?? false,
           createOutputMintAta: params.createOutputTokenAta ?? false,
           protocolParams: mapPumpFunParams(ext.params),
-          usePumpFunV2: this._config.usePumpfunV2 ?? ext.params.useV2Ix ?? false
+          outputMint: this.getOutputMint(params.outputTokenType)
         });
       }
       case "PumpSwap" /* PumpSwap */: {
@@ -7068,12 +7565,23 @@ var TradingClient = class {
           pcMint: p.pcMint,
           tokenCoin: p.tokenCoin,
           tokenPc: p.tokenPc,
-          coinReserve: BigInt(p.coinReserve),
-          pcReserve: BigInt(p.pcReserve)
+          ammOpenOrders: p.ammOpenOrders,
+          ammTargetOrders: p.ammTargetOrders,
+          serumProgram: p.serumProgram,
+          serumMarket: p.serumMarket,
+          serumBids: p.serumBids,
+          serumAsks: p.serumAsks,
+          serumEventQueue: p.serumEventQueue,
+          serumCoinVaultAccount: p.serumCoinVaultAccount,
+          serumPcVaultAccount: p.serumPcVaultAccount,
+          serumVaultSigner: p.serumVaultSigner,
+          coinReserve: p.coinReserve,
+          pcReserve: p.pcReserve
         };
         return buildRaydiumAmmV4SellInstructions({
           payer: this.payer.publicKey,
           inputMint: params.mint,
+          outputMint: this.getOutputMint(params.outputTokenType),
           inputAmount: inputAmt,
           slippageBasisPoints: slippage,
           fixedOutputAmount: params.fixedOutputTokenAmount !== void 0 ? BigInt(params.fixedOutputTokenAmount) : void 0,
@@ -7149,11 +7657,23 @@ var TradingClient = class {
     return result;
   }
   async executeTransaction(instructions, recentBlockhash, lookupTableAccount, waitConfirmed, simulate, execCtx) {
-    const blockhash = recentBlockhash ?? execCtx?.durableNonce?.nonceHash ?? (await this.connection.getLatestBlockhash(this.rpcCommitment())).blockhash;
+    const blockhash = recentBlockhash ?? execCtx?.durableNonce?.nonceHash;
+    if (!blockhash) {
+      return {
+        success: false,
+        signatures: [],
+        error: new TradeError(
+          105,
+          "recentBlockhash or durableNonce.nonceHash is required; trade execution hot path does not query RPC for blockhash"
+        ),
+        timings: []
+      };
+    }
     const swqosList = this._config.swqosConfigs ?? [];
     const tradeType = execCtx?.tradeType ?? "Buy" /* Buy */;
     const withTip = execCtx?.withTip ?? true;
-    const swqosMod = swqosList.length > 0 ? await import("./clients-VITWK7B6.mjs") : null;
+    const swqosMod = swqosList.length > 0 ? await this.getSwqosModule() : null;
+    const swqosClientForConfig = swqosMod ? (cfg) => this.getSwqosClient(swqosMod, cfg) : void 0;
     let effectiveSwqos = swqosList;
     if (swqosMod && !withTip) {
       effectiveSwqos = filterSwqosConfigsForWithTip(swqosList, withTip);
@@ -7185,7 +7705,8 @@ var TradingClient = class {
         gasMerged,
         this._config.mevProtection,
         this._config.rpcUrl,
-        this._logEnabled
+        this._logEnabled,
+        swqosClientForConfig
       );
       if (effectiveSwqos.length === 0) {
         return {
@@ -7219,7 +7740,8 @@ var TradingClient = class {
         swqosMod,
         this._config.mevProtection,
         this._config.rpcUrl,
-        this._logEnabled
+        this._logEnabled,
+        swqosClientForConfig
       );
       if (swqosTasks.length === 0) {
         return {
@@ -7281,7 +7803,8 @@ var TradingClient = class {
             swqosMod,
             [t.cfg],
             this._config.mevProtection,
-            this._config.rpcUrl
+            this._config.rpcUrl,
+            swqosClientForConfig
           ) : null;
           const txSim2 = buildSignedVersionedTransaction(
             this.payer,
@@ -7336,17 +7859,15 @@ var TradingClient = class {
       if (swqosMod) {
         const timings = [];
         const signatures = [];
-        const submitConcurrency = this._config.maxSwqosSubmitConcurrency ?? swqosTasks.length;
-        const results = await mapWithConcurrencyLimit(
-          swqosTasks,
-          submitConcurrency,
-          async (task) => {
-            const t0 = performance.now();
+        const submitTask = async (task) => {
+          const t0 = performance.now();
+          try {
             const tipPk = withTip ? resolveTipRecipientPubkey(
               swqosMod,
               [task.cfg],
               this._config.mevProtection,
-              this._config.rpcUrl
+              this._config.rpcUrl,
+              swqosClientForConfig
             ) : null;
             const tx = buildSignedVersionedTransaction(
               this.payer,
@@ -7355,33 +7876,30 @@ var TradingClient = class {
               lookupTableAccount
             );
             const raw = Buffer.from(tx.serialize());
-            const client = swqosMod.ClientFactory.createClient(
-              mapSwqosToClientConfig(task.cfg, this._config.mevProtection),
-              this._config.rpcUrl
-            );
-            try {
-              const pending = client.sendTransaction(tradeType, raw, false);
-              const sig = await (!waitConfirmed ? Promise.race([
-                pending,
-                new Promise(
-                  (_, reject) => setTimeout(
-                    () => reject(
-                      new Error(
-                        `SWQOS submit timed out after ${SWQOS_SUBMIT_TIMEOUT_MS_WHEN_NO_CONFIRM}ms`
-                      )
-                    ),
-                    SWQOS_SUBMIT_TIMEOUT_MS_WHEN_NO_CONFIRM
-                  )
+            const client = swqosClientForConfig(task.cfg);
+            const pending = client.sendTransaction(tradeType, raw, false);
+            const sig = await (!waitConfirmed ? Promise.race([
+              pending,
+              new Promise(
+                (_, reject) => setTimeout(
+                  () => reject(
+                    new Error(
+                      `SWQOS submit timed out after ${SWQOS_SUBMIT_TIMEOUT_MS_WHEN_NO_CONFIRM}ms`
+                    )
+                  ),
+                  SWQOS_SUBMIT_TIMEOUT_MS_WHEN_NO_CONFIRM
                 )
-              ]) : pending);
-              const duration = Math.round((performance.now() - t0) * 1e3);
-              return { ok: true, sig, task, duration };
-            } catch (e) {
-              const duration = Math.round((performance.now() - t0) * 1e3);
-              return { ok: false, err: e, task, duration };
-            }
+              )
+            ]) : pending);
+            const duration = Math.round((performance.now() - t0) * 1e3);
+            return { ok: true, sig, task, duration };
+          } catch (e) {
+            const duration = Math.round((performance.now() - t0) * 1e3);
+            return { ok: false, err: e, task, duration };
           }
-        );
+        };
+        const submitPromises = swqosTasks.map((task) => submitTask(task));
+        const results = waitConfirmed ? await Promise.all(submitPromises) : await collectUntilFirstSuccess(submitPromises, (result) => result.ok);
         for (const v of results) {
           timings.push({
             swqosType: v.task.cfg.type,
@@ -7389,7 +7907,7 @@ var TradingClient = class {
             gasFeeStrategyType: v.task.strategyType
           });
           if (v.ok) {
-            signatures.push(v.sig);
+            if (v.sig) signatures.push(v.sig);
           }
         }
         const success = signatures.length > 0;
@@ -7456,7 +7974,7 @@ function createTradeConfig(rpcUrl, swqosConfigs = [], options) {
   const { commitment, logEnabled, ...rest } = options ?? {};
   return {
     rpcUrl,
-    swqosConfigs,
+    swqosConfigs: normalizeSwqosConfigs(rpcUrl, swqosConfigs),
     ...rest,
     commitment: commitment ?? "confirmed",
     logEnabled: logEnabled ?? true
@@ -7638,11 +8156,17 @@ export {
   buildRaydiumAmmV4BuyInstructions,
   buildRaydiumAmmV4SellInstructions,
   AMM_INFO_SIZE,
+  MARKET_STATE_SIZE,
   decodeAmmInfo,
+  decodeMarketState,
+  deriveSerumVaultSigner,
   fetchAmmInfo,
+  fetchMarketState,
   METEORA_DAMM_V2_PROGRAM_ID,
   METEORA_DAMM_V2_AUTHORITY,
   METEORA_DAMM_V2_SWAP_DISCRIMINATOR,
+  METEORA_DAMM_V2_SWAP2_DISCRIMINATOR,
+  METEORA_DAMM_V2_SWAP_MODE_PARTIAL_FILL,
   METEORA_DAMM_V2_EVENT_AUTHORITY_SEED,
   getMeteoraDammV2EventAuthorityPda,
   buildMeteoraDammV2BuyInstructions,
@@ -7655,7 +8179,6 @@ export {
   extractHintsFromLogs,
   instructionErrorCodeFromMetaErr,
   confirmAnyTransactionSignature,
-  mapWithConcurrencyLimit,
   BYTES_PER_ACCOUNT,
   MAX_INSTRUCTIONS_WARN,
   Prefetch,
@@ -7691,6 +8214,7 @@ export {
   HotPathExecutor,
   TransactionBuilder,
   createHotPathExecutor,
+  mapWithConcurrencyLimit,
   fetchDurableNonceInfo,
   SecureKeyError,
   KeyNotAvailableError,
@@ -7710,6 +8234,8 @@ export {
   parseAddressLookupTable,
   AddressLookupTableCache,
   addressLookupTableCache,
+  DexType,
+  TradeType,
   defaultTradeExecuteOptions,
   BaseExecutor,
   PumpFunExecutor,
@@ -7727,13 +8253,15 @@ export {
   MetricsMiddleware,
   withStandardMiddlewares,
   withAllBuiltinMiddlewares,
-  DexType,
+  DexType2,
   TradeTokenType,
-  TradeType2 as TradeType,
+  TradeType3 as TradeType2,
   SwqosRegion,
   SwqosType,
   SwqosTransport,
   AstralaneTransport,
+  pumpFunParamsFromParserTrade,
+  pumpSwapParamsFromParserTrade,
   TradeConfigBuilder,
   recommendedSenderThreadCoreIndices,
   findPoolByMint2 as findPoolByMint,