sol-trade-sdk 0.1.0 → 0.1.2

package/src/instruction/meteora_damm_v2_builder.ts

@@ -25,6 +25,8 @@ import {
 // Program IDs and Constants
 // ============================================
 
+const SOL_TOKEN_ACCOUNT = new PublicKey("So11111111111111111111111111111111111111111");
+
 /** Meteora DAMM V2 program ID */
 export const METEORA_DAMM_V2_PROGRAM_ID = new PublicKey(
   "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"
@@ -43,6 +45,10 @@ export const METEORA_DAMM_V2_AUTHORITY = new PublicKey(
 export const METEORA_DAMM_V2_SWAP_DISCRIMINATOR: Buffer = Buffer.from([
   248, 198, 158, 145, 225, 117, 135, 200,
 ]);
+export const METEORA_DAMM_V2_SWAP2_DISCRIMINATOR: Buffer = Buffer.from([
+  65, 75, 63, 76, 235, 91, 91, 136,
+]);
+export const METEORA_DAMM_V2_SWAP_MODE_PARTIAL_FILL = 1;
 
 // ============================================
 // Seeds
@@ -109,6 +115,25 @@ export interface BuildMeteoraDammV2SellInstructionsParams {
 // Instruction Builders
 // ============================================
 
+function isDefaultPublicKey(pubkey: PublicKey): boolean {
+  return pubkey.equals(PublicKey.default);
+}
+
+function isMintMatch(requested: PublicKey, expected: PublicKey): boolean {
+  return (
+    requested.equals(expected) ||
+    (expected.equals(NATIVE_MINT) && requested.equals(SOL_TOKEN_ACCOUNT))
+  );
+}
+
+function ensureExpectedMint(label: string, requested: PublicKey, expected: PublicKey): void {
+  if (!isDefaultPublicKey(requested) && !isMintMatch(requested, expected)) {
+    throw new Error(
+      `${label} must match the Meteora DAMM v2 pool side (${expected.toBase58()}), got ${requested.toBase58()}`
+    );
+  }
+}
+
 /**
  * Build buy instructions for Meteora DAMM V2 protocol
  */
@@ -117,8 +142,8 @@ export function buildMeteoraDammV2BuyInstructions(
 ): TransactionInstruction[] {
   const {
     payer,
-    inputMint,
-    outputMint,
+    inputMint: requestedInputMint,
+    outputMint: requestedOutputMint,
     inputAmount,
     fixedOutputAmount,
     createInputMintAta = true,
@@ -162,6 +187,11 @@ export function buildMeteoraDammV2BuyInstructions(
   // Determine swap direction
   const isAIn = tokenAMint.equals(WSOL_TOKEN_ACCOUNT) || tokenAMint.equals(USDC_TOKEN_ACCOUNT);
 
+  const inputMint = isAIn ? tokenAMint : tokenBMint;
+  const outputMint = isAIn ? tokenBMint : tokenAMint;
+  ensureExpectedMint("inputMint", requestedInputMint, inputMint);
+  ensureExpectedMint("outputMint", requestedOutputMint, outputMint);
+
   // Derive user token accounts
   const inputTokenAccount = getAssociatedTokenAddressSync(
     inputMint,
@@ -179,8 +209,11 @@ export function buildMeteoraDammV2BuyInstructions(
   // Derive event authority
   const eventAuthority = getMeteoraDammV2EventAuthorityPda();
 
-  // Handle WSOL wrapping
-  if (createInputMintAta && isWsol) {
+  const inputTokenProgram = isAIn ? tokenAProgram : tokenBProgram;
+  const outputTokenProgram = isAIn ? tokenBProgram : tokenAProgram;
+
+  // Handle input account creation/wrapping
+  if (createInputMintAta && inputMint.equals(WSOL_TOKEN_ACCOUNT)) {
     const wsolAta = getAssociatedTokenAddressSync(NATIVE_MINT, payerPubkey, true);
     instructions.push(
       createAssociatedTokenAccountInstruction(
@@ -191,7 +224,24 @@ export function buildMeteoraDammV2BuyInstructions(
         TOKEN_PROGRAM_ID
       )
     );
+    instructions.push(
+      SystemProgram.transfer({
+        fromPubkey: payerPubkey,
+        toPubkey: wsolAta,
+        lamports: Number(inputAmount),
+      })
+    );
     instructions.push(createSyncNativeInstruction(wsolAta));
+  } else if (createInputMintAta) {
+    instructions.push(
+      createAssociatedTokenAccountInstruction(
+        payerPubkey,
+        inputTokenAccount,
+        payerPubkey,
+        inputMint,
+        inputTokenProgram
+      )
+    );
   }
 
   // Create output mint ATA if needed
@@ -202,18 +252,19 @@ export function buildMeteoraDammV2BuyInstructions(
         outputTokenAccount,
         payerPubkey,
         outputMint,
-        TOKEN_PROGRAM_ID
+        outputTokenProgram
       )
     );
   }
 
-  // Build instruction data
-  const data = Buffer.alloc(24);
-  METEORA_DAMM_V2_SWAP_DISCRIMINATOR.copy(data, 0);
+  // Build swap2 instruction data
+  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);
 
-  // Build accounts (14 accounts)
+  // Build accounts (13 accounts)
   const accounts: AccountMeta[] = [
     { pubkey: METEORA_DAMM_V2_AUTHORITY, isSigner: false, isWritable: false },
     { pubkey: pool, isSigner: false, isWritable: true },
@@ -226,7 +277,6 @@ export function buildMeteoraDammV2BuyInstructions(
     { 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 },
   ];
@@ -240,7 +290,7 @@ export function buildMeteoraDammV2BuyInstructions(
   );
 
   // Close WSOL ATA if requested
-  if (closeInputMintAta && isWsol) {
+  if (closeInputMintAta && inputMint.equals(WSOL_TOKEN_ACCOUNT)) {
     const wsolAta = getAssociatedTokenAddressSync(NATIVE_MINT, payerPubkey, true);
     instructions.push(
       createCloseAccountInstruction(wsolAta, payerPubkey, payerPubkey, [], TOKEN_PROGRAM_ID)
@@ -258,8 +308,8 @@ export function buildMeteoraDammV2SellInstructions(
 ): TransactionInstruction[] {
   const {
     payer,
-    inputMint,
-    outputMint,
+    inputMint: requestedInputMint,
+    outputMint: requestedOutputMint,
     inputAmount,
     fixedOutputAmount,
     createOutputMintAta = true,
@@ -303,6 +353,11 @@ export function buildMeteoraDammV2SellInstructions(
   // Determine swap direction (selling token for WSOL/USDC)
   const isAIn = tokenBMint.equals(WSOL_TOKEN_ACCOUNT) || tokenBMint.equals(USDC_TOKEN_ACCOUNT);
 
+  const inputMint = isAIn ? tokenAMint : tokenBMint;
+  const outputMint = isAIn ? tokenBMint : tokenAMint;
+  ensureExpectedMint("inputMint", requestedInputMint, inputMint);
+  ensureExpectedMint("outputMint", requestedOutputMint, outputMint);
+
   // Derive user token accounts
   const inputTokenAccount = getAssociatedTokenAddressSync(
     inputMint,
@@ -320,8 +375,11 @@ export function buildMeteoraDammV2SellInstructions(
   // Derive event authority
   const eventAuthority = getMeteoraDammV2EventAuthorityPda();
 
-  // Create WSOL ATA for receiving if needed
-  if (createOutputMintAta && isWsol) {
+  const inputTokenProgram = isAIn ? tokenAProgram : tokenBProgram;
+  const outputTokenProgram = isAIn ? tokenBProgram : tokenAProgram;
+
+  // Create output ATA for receiving if needed
+  if (createOutputMintAta && outputMint.equals(WSOL_TOKEN_ACCOUNT)) {
     const wsolAta = getAssociatedTokenAddressSync(NATIVE_MINT, payerPubkey, true);
     instructions.push(
       createAssociatedTokenAccountInstruction(
@@ -332,13 +390,24 @@ export function buildMeteoraDammV2SellInstructions(
         TOKEN_PROGRAM_ID
       )
     );
+  } else if (createOutputMintAta) {
+    instructions.push(
+      createAssociatedTokenAccountInstruction(
+        payerPubkey,
+        outputTokenAccount,
+        payerPubkey,
+        outputMint,
+        outputTokenProgram
+      )
+    );
   }
 
-  // Build instruction data
-  const data = Buffer.alloc(24);
-  METEORA_DAMM_V2_SWAP_DISCRIMINATOR.copy(data, 0);
+  // Build swap2 instruction data
+  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);
 
   // Build accounts
   const accounts: AccountMeta[] = [
@@ -353,7 +422,6 @@ export function buildMeteoraDammV2SellInstructions(
     { 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 },
   ];
@@ -367,7 +435,7 @@ export function buildMeteoraDammV2SellInstructions(
   );
 
   // Close WSOL ATA if requested
-  if (closeOutputMintAta && isWsol) {
+  if (closeOutputMintAta && outputMint.equals(WSOL_TOKEN_ACCOUNT)) {
     const wsolAta = getAssociatedTokenAddressSync(NATIVE_MINT, payerPubkey, true);
     instructions.push(
       createCloseAccountInstruction(wsolAta, payerPubkey, payerPubkey, [], TOKEN_PROGRAM_ID)

package/src/instruction/pumpfun_builder.ts

@@ -15,7 +15,6 @@ import {
 } from "@solana/web3.js";
 import {
   getAssociatedTokenAddressSync,
-  createAssociatedTokenAccountInstruction,
   createAssociatedTokenAccountIdempotentInstruction,
   TOKEN_PROGRAM_ID,
   TOKEN_2022_PROGRAM_ID,
@@ -25,6 +24,8 @@ import {
   NATIVE_MINT,
 } from "@solana/spl-token";
 
+const SOL_TOKEN_ACCOUNT = new PublicKey("So11111111111111111111111111111111111111111");
+
 // ============================================
 // Program IDs and Constants
 // ============================================
@@ -281,35 +282,34 @@ export interface PumpFunParams {
   closeTokenAccountWhenSell?: boolean;
   /** From parser/gRPC (`tradeEvent.feeRecipient`); default pubkey → random pool */
   feeRecipient?: PublicKey;
-  /** Quote mint for V2 instructions; default means WSOL. */
+  /** Layout selector: default/Solscan SOL sentinel keeps legacy SOL; WSOL/USDC selects V2. */
   quoteMint?: PublicKey;
-  /** Per-params V2 toggle; global `TradeConfig.usePumpfunV2` also maps here. */
-  useV2Ix?: boolean;
 }
 
 export interface PumpFunBuildBuyParams {
   payer: Keypair | PublicKey;
+  inputMint?: PublicKey;
   outputMint: PublicKey;
   inputAmount: bigint;
   slippageBasisPoints?: bigint;
   fixedOutputAmount?: bigint;
   createOutputMintAta?: boolean;
   createInputMintAta?: boolean;
+  closeInputMintAta?: boolean;
   protocolParams: PumpFunParams;
   useExactSolAmount?: boolean;
-  usePumpFunV2?: boolean;
 }
 
 export interface PumpFunBuildSellParams {
   payer: Keypair | PublicKey;
   inputMint: PublicKey;
+  outputMint?: PublicKey;
   inputAmount: bigint;
   slippageBasisPoints?: bigint;
   fixedOutputAmount?: bigint;
   createOutputMintAta?: boolean;
   closeInputMintAta?: boolean;
   protocolParams: PumpFunParams;
-  usePumpFunV2?: boolean;
 }
 
 // ============================================
@@ -391,7 +391,40 @@ function effectivePumpMintTokenProgram(mint: PublicKey, protocolParams: PumpFunP
 }
 
 function effectiveQuoteMint(protocolParams: PumpFunParams): PublicKey {
-  return isUsablePubkey(protocolParams.quoteMint) ? protocolParams.quoteMint : NATIVE_MINT;
+  if (!isUsablePubkey(protocolParams.quoteMint) || protocolParams.quoteMint.equals(SOL_TOKEN_ACCOUNT)) {
+    return NATIVE_MINT;
+  }
+  return protocolParams.quoteMint;
+}
+
+function usesPumpFunV2Layout(protocolParams: PumpFunParams): boolean {
+  return isUsablePubkey(protocolParams.quoteMint) && !protocolParams.quoteMint.equals(SOL_TOKEN_ACCOUNT);
+}
+
+function isSolQuoteMint(mint: PublicKey): boolean {
+  return mint.equals(SOL_TOKEN_ACCOUNT) || mint.equals(NATIVE_MINT);
+}
+
+function validateV2BuyQuoteMint(inputMint: PublicKey, quoteMint: PublicKey): void {
+  if (isSolQuoteMint(quoteMint)) {
+    if (inputMint.equals(SOL_TOKEN_ACCOUNT) || 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: PublicKey, quoteMint: PublicKey): void {
+  if (isSolQuoteMint(quoteMint)) {
+    if (outputMint.equals(SOL_TOKEN_ACCOUNT) || 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: PublicKey, owner: PublicKey, tokenProgram: PublicKey): PublicKey {
@@ -404,6 +437,36 @@ function associatedTokenAddress(mint: PublicKey, owner: PublicKey, tokenProgram:
   );
 }
 
+function pushCreateOrWrapUserTokenAccount(
+  instructions: TransactionInstruction[],
+  payer: PublicKey,
+  ata: PublicKey,
+  mint: PublicKey,
+  tokenProgram: PublicKey,
+  amount: bigint
+): void {
+  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: bigint,
   bondingCurve: PumpFunBondingCurve,
@@ -457,22 +520,24 @@ export function buildPumpFunBuyInstructions(
 ): TransactionInstruction[] {
 	const {
 	  payer,
+	  inputMint = SOL_TOKEN_ACCOUNT,
 	  outputMint,
 	  inputAmount,
 	  slippageBasisPoints = BigInt(1000),
 	  fixedOutputAmount,
 	  createOutputMintAta = true,
 	  createInputMintAta = false,
+	  closeInputMintAta = false,
 	  protocolParams,
 	  useExactSolAmount = true,
-	  usePumpFunV2 = false,
 	} = params;
 
-	if (usePumpFunV2 || protocolParams.useV2Ix || isUsablePubkey(protocolParams.quoteMint)) {
+	if (usesPumpFunV2Layout(protocolParams)) {
 	  return buildPumpFunBuyV2Instructions({
 	    ...params,
+	    inputMint,
 	    createInputMintAta,
-	    usePumpFunV2: true,
+	    closeInputMintAta,
 	  });
 	}
 
@@ -518,12 +583,13 @@ export function buildPumpFunBuyInstructions(
   // Create ATA if needed
   if (createOutputMintAta) {
     instructions.push(
-      createAssociatedTokenAccountInstruction(
+      createAssociatedTokenAccountIdempotentInstruction(
         payerPubkey,
         userTokenAccount,
         payerPubkey,
         outputMint,
-        tokenProgramId
+        tokenProgramId,
+        SPL_ASSOCIATED_TOKEN_PROGRAM_ID
       )
     );
   }
@@ -534,9 +600,7 @@ export function buildPumpFunBuyInstructions(
   const bondingCurveV2 = getBondingCurveV2Pda(outputMint);
 
   // Track volume for cashback coins
-  const trackVolume = bondingCurve.isCashbackCoin
-    ? Buffer.from([1, 1])
-    : Buffer.from([1, 0]);
+  const trackVolume = bondingCurve.isCashbackCoin ? 1 : 0;
 
   const buyTokenAmount = fixedOutputAmount
     ? fixedOutputAmount
@@ -545,23 +609,27 @@ export function buildPumpFunBuyInstructions(
 
   // Build instruction data
   let data: Buffer;
-  if (useExactSolAmount) {
+  if (fixedOutputAmount !== undefined) {
+    data = Buffer.alloc(25);
+    PUMPFUN_BUY_DISCRIMINATOR.copy(data, 0);
+    data.writeBigUInt64LE(fixedOutputAmount, 8);
+    data.writeBigUInt64LE(inputAmount, 16);
+    data[24] = trackVolume;
+  } else if (useExactSolAmount) {
     // buy_exact_sol_in(spendable_sol_in: u64, min_tokens_out: u64, track_volume)
-    const minTokensOut = fixedOutputAmount
-      ? fixedOutputAmount
-      : calculateWithSlippageSell(buyTokenAmount, slippageBasisPoints);
-    data = Buffer.alloc(26);
+    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 {
     // buy(token_amount: u64, max_sol_cost: u64, track_volume)
-    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;
   }
 
   // Build accounts
@@ -607,20 +675,20 @@ export function buildPumpFunSellInstructions(
   const {
     payer,
     inputMint,
+    outputMint = SOL_TOKEN_ACCOUNT,
 	  inputAmount,
 	  slippageBasisPoints = BigInt(1000),
 	  fixedOutputAmount,
 	  createOutputMintAta = false,
 	  closeInputMintAta = false,
 	  protocolParams,
-	  usePumpFunV2 = false,
 	} = params;
 
-	if (usePumpFunV2 || protocolParams.useV2Ix || isUsablePubkey(protocolParams.quoteMint)) {
+	if (usesPumpFunV2Layout(protocolParams)) {
 	  return buildPumpFunSellV2Instructions({
 	    ...params,
+	    outputMint,
 	    createOutputMintAta,
-	    usePumpFunV2: true,
 	  });
 	}
 
@@ -740,12 +808,14 @@ export function buildPumpFunBuyV2Instructions(
 ): TransactionInstruction[] {
   const {
     payer,
+    inputMint = SOL_TOKEN_ACCOUNT,
     outputMint,
     inputAmount,
     slippageBasisPoints = BigInt(1000),
     fixedOutputAmount,
     createOutputMintAta = true,
     createInputMintAta = false,
+    closeInputMintAta = false,
     protocolParams,
     useExactSolAmount = true,
   } = params;
@@ -767,6 +837,7 @@ export function buildPumpFunBuyV2Instructions(
 
   const baseTokenProgram = effectivePumpMintTokenProgram(outputMint, protocolParams);
   const quoteMint = effectiveQuoteMint(protocolParams);
+  validateV2BuyQuoteMint(inputMint, quoteMint);
   const quoteTokenProgram = TOKEN_PROGRAM_ID;
 
   const associatedBaseBondingCurve = associatedTokenAddress(
@@ -824,37 +895,42 @@ export function buildPumpFunBuyV2Instructions(
     );
   }
 
-  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: Buffer;
-  if (useExactSolAmount) {
-    const minTokensOut = fixedOutputAmount
-      ? fixedOutputAmount
-      : calculateWithSlippageSell(buyTokenAmount, slippageBasisPoints);
+  let quoteAmountToFund: bigint;
+  if (fixedOutputAmount !== undefined) {
+    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: AccountMeta[] = [
@@ -895,6 +971,18 @@ export function buildPumpFunBuyV2Instructions(
     })
   );
 
+  if (closeInputMintAta && quoteMint.equals(NATIVE_MINT)) {
+    instructions.push(
+      createCloseAccountInstruction(
+        associatedQuoteUser,
+        payerPubkey,
+        payerPubkey,
+        [],
+        quoteTokenProgram
+      )
+    );
+  }
+
   return instructions;
 }
 
@@ -907,6 +995,7 @@ export function buildPumpFunSellV2Instructions(
   const {
     payer,
     inputMint,
+    outputMint = SOL_TOKEN_ACCOUNT,
     inputAmount,
     slippageBasisPoints = BigInt(1000),
     fixedOutputAmount,
@@ -932,6 +1021,7 @@ export function buildPumpFunSellV2Instructions(
 
   const baseTokenProgram = effectivePumpMintTokenProgram(inputMint, protocolParams);
   const quoteMint = effectiveQuoteMint(protocolParams);
+  validateV2SellQuoteMint(outputMint, quoteMint);
   const quoteTokenProgram = TOKEN_PROGRAM_ID;
 
   const associatedBaseBondingCurve = associatedTokenAddress(