pump-trader 1.1.3 → 1.1.5

package/index.ts

@@ -3,6 +3,7 @@ import {
   PublicKey,
   Transaction,
   TransactionInstruction,
+  AccountMeta,
   SystemProgram,
   ComputeBudgetProgram,
   Keypair
@@ -63,6 +64,7 @@ interface BondingCurveState {
   realSolReserves: bigint;
   tokenTotalSupply: bigint;
   complete: boolean;
+  quoteMint?: PublicKey;
   isMayhemMode?: boolean;
   isCashbackCoin?: boolean;
 }
@@ -153,6 +155,16 @@ const DISCRIMINATORS = {
 
 const AMM_FEE_BPS = 100n;
 const BPS_DENOMINATOR = 10000n;
+const PUMP_NEW_FEE_RECIPIENTS = [
+  "5YxQFdt3Tr9zJLvkFccqXVUwhdTWJQc1fFg2YPbxvxeD",
+  "9M4giFFMxmFGXtc3feFzRai56WbBqehoSeRE5GK7gf7",
+  "GXPFM2caqTtQYC2cJ5yJRi9VDkpsYZXzYdwYpGnLmtDL",
+  "3BpXnfJaUTiwXnJNe7Ej1rcbzqTTQUvLShZaWazebsVR",
+  "5cjcW9wExnJJiqgLjq7DEG75Pm6JBgE1hNv4B2vHXUW6",
+  "EHAAiTxcdDwQ3U4bU6YcMsQGaekdzLS3B5SmYo46kJtL",
+  "5eHhjP8JaYkz83CWwvGU2uMUXefd3AazWGx4gpcuEEYD",
+  "A7hAgCzFw14fejgCp387JUJRMNyz4j89JKnhtKU8piqW"
+].map((value) => new PublicKey(value));
 
 /* ================= 工具函数 ================= */
 
@@ -394,6 +406,102 @@ export class PumpTrader {
     )[0];
   }
 
+  private pickFeeRecipient(index = 0): PublicKey {
+    return PUMP_NEW_FEE_RECIPIENTS[index % PUMP_NEW_FEE_RECIPIENTS.length];
+  }
+
+  private buildBondingBuyKeys(args: {
+    global: PublicKey;
+    globalFeeRecipient: PublicKey;
+    mint: PublicKey;
+    bonding: PublicKey;
+    associatedBondingCurve: PublicKey;
+    userAta: PublicKey;
+    wallet: PublicKey;
+    creatorVault: PublicKey;
+    eventAuthority: PublicKey;
+    pumpProgram: PublicKey;
+    globalVolumeAccumulator: PublicKey;
+    userVolumeAccumulator: PublicKey;
+    feeConfig: PublicKey;
+    feeProgram: PublicKey;
+    bondingCurveV2: PublicKey;
+    feeRecipient: PublicKey;
+    tokenProgramId?: PublicKey;
+  }): AccountMeta[] {
+    const tokenProgramId = args.tokenProgramId ?? TOKEN_PROGRAM_ID;
+
+    return [
+      { pubkey: args.global, isSigner: false, isWritable: false },
+      { pubkey: args.globalFeeRecipient, isSigner: false, isWritable: true },
+      { pubkey: args.mint, isSigner: false, isWritable: false },
+      { pubkey: args.bonding, isSigner: false, isWritable: true },
+      { pubkey: args.associatedBondingCurve, isSigner: false, isWritable: true },
+      { pubkey: args.userAta, isSigner: false, isWritable: true },
+      { pubkey: args.wallet, isSigner: true, isWritable: true },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+      { pubkey: tokenProgramId, isSigner: false, isWritable: false },
+      { pubkey: args.creatorVault, isSigner: false, isWritable: true },
+      { pubkey: args.eventAuthority, isSigner: false, isWritable: false },
+      { pubkey: args.pumpProgram, isSigner: false, isWritable: false },
+      { pubkey: args.globalVolumeAccumulator, isSigner: false, isWritable: false },
+      { pubkey: args.userVolumeAccumulator, isSigner: false, isWritable: true },
+      { pubkey: args.feeConfig, isSigner: false, isWritable: false },
+      { pubkey: args.feeProgram, isSigner: false, isWritable: false },
+      { pubkey: args.bondingCurveV2, isSigner: false, isWritable: false },
+      { pubkey: args.feeRecipient, isSigner: false, isWritable: true }
+    ];
+  }
+
+  private buildBondingSellKeys(args: {
+    global: PublicKey;
+    globalFeeRecipient: PublicKey;
+    mint: PublicKey;
+    bonding: PublicKey;
+    associatedBondingCurve: PublicKey;
+    userAta: PublicKey;
+    wallet: PublicKey;
+    creatorVault: PublicKey;
+    eventAuthority: PublicKey;
+    pumpProgram: PublicKey;
+    feeConfig: PublicKey;
+    feeProgram: PublicKey;
+    bondingCurveV2: PublicKey;
+    feeRecipient: PublicKey;
+    isCashbackCoin: boolean;
+    userVolumeAccumulator: PublicKey;
+    tokenProgramId?: PublicKey;
+  }): AccountMeta[] {
+    const tokenProgramId = args.tokenProgramId ?? TOKEN_PROGRAM_ID;
+    const keys: AccountMeta[] = [
+      { pubkey: args.global, isSigner: false, isWritable: false },
+      { pubkey: args.globalFeeRecipient, isSigner: false, isWritable: true },
+      { pubkey: args.mint, isSigner: false, isWritable: false },
+      { pubkey: args.bonding, isSigner: false, isWritable: true },
+      { pubkey: args.associatedBondingCurve, isSigner: false, isWritable: true },
+      { pubkey: args.userAta, isSigner: false, isWritable: true },
+      { pubkey: args.wallet, isSigner: true, isWritable: true },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+      { pubkey: args.creatorVault, isSigner: false, isWritable: true },
+      { pubkey: tokenProgramId, isSigner: false, isWritable: false },
+      { pubkey: args.eventAuthority, isSigner: false, isWritable: false },
+      { pubkey: args.pumpProgram, isSigner: false, isWritable: false },
+      { pubkey: args.feeConfig, isSigner: false, isWritable: false },
+      { pubkey: args.feeProgram, isSigner: false, isWritable: false }
+    ];
+
+    if (args.isCashbackCoin) {
+      keys.push({ pubkey: args.userVolumeAccumulator, isSigner: false, isWritable: true });
+    }
+
+    keys.push(
+      { pubkey: args.bondingCurveV2, isSigner: false, isWritable: false },
+      { pubkey: args.feeRecipient, isSigner: false, isWritable: true }
+    );
+
+    return keys;
+  }
+
   async loadBonding(mint: PublicKey): Promise<BondingInfo> {
     const bonding = this.getBondingPda(mint);
     const acc = await this.connection.getAccountInfo(bonding);
@@ -414,6 +522,11 @@ export class PumpTrader {
     const creator = new PublicKey(data.slice(offset, offset + 32));
     offset += 32;
 
+    if (offset + 32 <= data.length - 2) {
+      state.quoteMint = new PublicKey(data.slice(offset, offset + 32));
+      offset += 32;
+    }
+
     state.isMayhemMode = offset < data.length ? data[offset] === 1 : false;
     offset += 1;
     state.isCashbackCoin = offset < data.length ? data[offset] === 1 : false;
@@ -454,19 +567,21 @@ export class PumpTrader {
   async getPriceAndStatus(tokenAddr: string): Promise<{ price: number; completed: boolean }> {
     const mint = new PublicKey(tokenAddr);
     const { state } = await this.loadBonding(mint);
+    const quoteMint = this.getEffectiveQuoteMint(state.quoteMint);
 
     if (state.complete) {
-      const price = await this.getAmmPrice(mint);
+      const price = await this.getAmmPrice(mint, quoteMint);
       return { price, completed: true };
     }
 
     const oneToken = BigInt(1_000_000);
-    const solOut = this.calcSell(oneToken, state);
-    const price = Number(solOut) / 1e9;
+    const quoteOut = this.calcSell(oneToken, state);
+    const quoteDecimals = await this.getMintDecimals(quoteMint);
+    const price = Number(quoteOut) / 10 ** quoteDecimals;
     return { price, completed: false };
   }
 
-  async getAmmPrice(mint: PublicKey): Promise<number> {
+  async getAmmPrice(mint: PublicKey, quoteMint: PublicKey = SOL_MINT): Promise<number> {
     const [poolCreator] = PublicKey.findProgramAddressSync(
       [Buffer.from("pool-authority"), mint.toBuffer()],
       PROGRAM_IDS.PUMP
@@ -474,7 +589,7 @@ export class PumpTrader {
 
     const indexBuffer = new BN(0).toArrayLike(Buffer, "le", 2);
     const [pool] = PublicKey.findProgramAddressSync(
-      [Buffer.from("pool"), indexBuffer, poolCreator.toBuffer(), mint.toBuffer(), SOL_MINT.toBuffer()],
+      [Buffer.from("pool"), indexBuffer, poolCreator.toBuffer(), mint.toBuffer(), quoteMint.toBuffer()],
       PROGRAM_IDS.PUMP_AMM
     );
 
@@ -490,6 +605,28 @@ export class PumpTrader {
     return quoteInfo.value.uiAmount! / baseInfo.value.uiAmount!;
   }
 
+  private getEffectiveQuoteMint(quoteMint?: PublicKey): PublicKey {
+    if (!quoteMint || quoteMint.equals(PublicKey.default)) {
+      return SOL_MINT;
+    }
+    return quoteMint;
+  }
+
+  private async getMintDecimals(mint: PublicKey): Promise<number> {
+    if (mint.equals(SOL_MINT)) {
+      return 9;
+    }
+
+    const mintInfo = await this.connection.getParsedAccountInfo(mint);
+    const parsedData = mintInfo.value?.data;
+
+    if (parsedData && "parsed" in parsedData) {
+      return parsedData.parsed.info.decimals;
+    }
+
+    throw new Error(`Unable to determine mint decimals for ${mint.toBase58()}`);
+  }
+
   /* ---------- 余额查询 ---------- */
 
   /**
@@ -777,6 +914,7 @@ export class PumpTrader {
       [Buffer.from("fee_config"), SEEDS.FEE_CONFIG],
       PROGRAM_IDS.FEE
     );
+    const feeRecipient = this.pickFeeRecipient();
 
     for (let i = 0; i < solChunks.length; i++) {
       try {
@@ -800,25 +938,25 @@ export class PumpTrader {
         tx.add(
           new TransactionInstruction({
             programId: PROGRAM_IDS.PUMP,
-            keys: [
-              { pubkey: this.global, isSigner: false, isWritable: false },
-              { pubkey: this.globalState!.feeRecipient, isSigner: false, isWritable: true },
-              { pubkey: mint, isSigner: false, isWritable: false },
-              { pubkey: bonding, isSigner: false, isWritable: true },
-              { pubkey: associatedBondingCurve, isSigner: false, isWritable: true },
-              { pubkey: userAta, isSigner: false, isWritable: true },
-              { pubkey: this.wallet.publicKey, isSigner: true, isWritable: true },
-              { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-              { pubkey: tokenProgram.programId, isSigner: false, isWritable: false },
-              { pubkey: creatorVault, isSigner: false, isWritable: true },
-              { pubkey: PROGRAM_IDS.EVENT_AUTHORITY, isSigner: false, isWritable: false },
-              { pubkey: PROGRAM_IDS.PUMP, isSigner: false, isWritable: false },
-              { pubkey: globalVolumeAccumulator, isSigner: false, isWritable: false },
-              { pubkey: userVolumeAccumulator, isSigner: false, isWritable: true },
-              { pubkey: feeConfig, isSigner: false, isWritable: false },
-              { pubkey: PROGRAM_IDS.FEE, isSigner: false, isWritable: false },
-              { pubkey: bondingCurveV2, isSigner: false, isWritable: false }
-            ],
+            keys: this.buildBondingBuyKeys({
+              global: this.global,
+              globalFeeRecipient: this.globalState!.feeRecipient,
+              mint,
+              bonding,
+              associatedBondingCurve,
+              userAta,
+              wallet: this.wallet.publicKey,
+              creatorVault,
+              eventAuthority: PROGRAM_IDS.EVENT_AUTHORITY,
+              pumpProgram: PROGRAM_IDS.PUMP,
+              globalVolumeAccumulator,
+              userVolumeAccumulator,
+              feeConfig,
+              feeProgram: PROGRAM_IDS.FEE,
+              bondingCurveV2,
+              feeRecipient,
+              tokenProgramId: tokenProgram.programId
+            }),
             data: Buffer.concat([DISCRIMINATORS.BUY, u64(tokenOut), u64(maxSol)])
           })
         );
@@ -901,12 +1039,7 @@ export class PumpTrader {
       [Buffer.from("user_volume_accumulator"), this.wallet.publicKey.toBuffer()],
       PROGRAM_IDS.PUMP
     );
-
-    const sellRemainingKeys = [];
-    if (state.isCashbackCoin) {
-      sellRemainingKeys.push({ pubkey: userVolumeAccumulator, isSigner: false, isWritable: true });
-    }
-    sellRemainingKeys.push({ pubkey: bondingCurveV2, isSigner: false, isWritable: false });
+    const feeRecipient = this.pickFeeRecipient();
 
     for (let i = 0; i < tokenChunks.length; i++) {
       try {
@@ -928,23 +1061,25 @@ export class PumpTrader {
         tx.add(
           new TransactionInstruction({
             programId: PROGRAM_IDS.PUMP,
-            keys: [
-              { pubkey: this.global, isSigner: false, isWritable: false },
-              { pubkey: this.globalState!.feeRecipient, isSigner: false, isWritable: true },
-              { pubkey: mint, isSigner: false, isWritable: false },
-              { pubkey: bonding, isSigner: false, isWritable: true },
-              { pubkey: associatedBondingCurve, isSigner: false, isWritable: true },
-              { pubkey: userAta, isSigner: false, isWritable: true },
-              { pubkey: this.wallet.publicKey, isSigner: true, isWritable: true },
-              { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-              { pubkey: creatorVault, isSigner: false, isWritable: true },
-              { pubkey: tokenProgram.programId, isSigner: false, isWritable: false },
-              { pubkey: PROGRAM_IDS.EVENT_AUTHORITY, isSigner: false, isWritable: false },
-              { pubkey: PROGRAM_IDS.PUMP, isSigner: false, isWritable: false },
-              { pubkey: feeConfig, isSigner: false, isWritable: false },
-              { pubkey: PROGRAM_IDS.FEE, isSigner: false, isWritable: false },
-              ...sellRemainingKeys
-            ],
+            keys: this.buildBondingSellKeys({
+              global: this.global,
+              globalFeeRecipient: this.globalState!.feeRecipient,
+              mint,
+              bonding,
+              associatedBondingCurve,
+              userAta,
+              wallet: this.wallet.publicKey,
+              creatorVault,
+              eventAuthority: PROGRAM_IDS.EVENT_AUTHORITY,
+              pumpProgram: PROGRAM_IDS.PUMP,
+              feeConfig,
+              feeProgram: PROGRAM_IDS.FEE,
+              bondingCurveV2,
+              feeRecipient,
+              isCashbackCoin: !!state.isCashbackCoin,
+              userVolumeAccumulator,
+              tokenProgramId: tokenProgram.programId
+            }),
             data: Buffer.concat([
               DISCRIMINATORS.SELL,
               u64(tokenIn),
@@ -1269,6 +1404,14 @@ export class PumpTrader {
       TOKEN_PROGRAM_ID,
       ASSOCIATED_TOKEN_PROGRAM_ID
     );
+    const newFeeRecipient = this.pickFeeRecipient();
+    const newFeeRecipientTokenAccount = getAssociatedTokenAddressSync(
+      poolKeys.quoteMint,
+      newFeeRecipient,
+      true,
+      TOKEN_PROGRAM_ID,
+      ASSOCIATED_TOKEN_PROGRAM_ID
+    );
 
     const remainingKeys = [];
     if (poolKeys.isCashbackCoin) {
@@ -1282,6 +1425,10 @@ export class PumpTrader {
       remainingKeys.push({ pubkey: userVolumeAccumulatorWsolAta, isSigner: false, isWritable: true });
     }
     remainingKeys.push({ pubkey: poolV2, isSigner: false, isWritable: false });
+    remainingKeys.push(
+      { pubkey: newFeeRecipient, isSigner: false, isWritable: false },
+      { pubkey: newFeeRecipientTokenAccount, isSigner: false, isWritable: true }
+    );
 
     return new TransactionInstruction({
       programId: PROGRAM_IDS.PUMP_AMM,
@@ -1362,6 +1509,14 @@ export class PumpTrader {
       TOKEN_PROGRAM_ID,
       ASSOCIATED_TOKEN_PROGRAM_ID
     );
+    const newFeeRecipient = this.pickFeeRecipient();
+    const newFeeRecipientTokenAccount = getAssociatedTokenAddressSync(
+      poolKeys.quoteMint,
+      newFeeRecipient,
+      true,
+      TOKEN_PROGRAM_ID,
+      ASSOCIATED_TOKEN_PROGRAM_ID
+    );
 
     const [userVolumeAccumulator] = PublicKey.findProgramAddressSync(
       [Buffer.from("user_volume_accumulator"), this.wallet.publicKey.toBuffer()],
@@ -1384,6 +1539,10 @@ export class PumpTrader {
       );
     }
     remainingKeys.push({ pubkey: poolV2, isSigner: false, isWritable: false });
+    remainingKeys.push(
+      { pubkey: newFeeRecipient, isSigner: false, isWritable: false },
+      { pubkey: newFeeRecipientTokenAccount, isSigner: false, isWritable: true }
+    );
 
     return new TransactionInstruction({
       programId: PROGRAM_IDS.PUMP_AMM,

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "pump-trader",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "PumpFun 交易库 - 自动判断 Token Program 和内盘/外盘",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
+    "test": "node --test --import tsx tests/**/*.test.ts",
     "format": "prettier --write ."
   },
   "keywords": [

package/tests/instruction-accounts.test.ts

@@ -0,0 +1,301 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import bs58 from "bs58";
+import { Keypair, PublicKey } from "@solana/web3.js";
+import { ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddressSync, TOKEN_PROGRAM_ID } from "@solana/spl-token";
+
+import { PumpTrader } from "../index";
+
+const SOL_MINT = new PublicKey("So11111111111111111111111111111111111111112");
+const USDC_MINT = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+const FEE_RECIPIENTS = [
+  "5YxQFdt3Tr9zJLvkFccqXVUwhdTWJQc1fFg2YPbxvxeD",
+  "9M4giFFMxmFGXtc3feFzRai56WbBqehoSeRE5GK7gf7",
+  "GXPFM2caqTtQYC2cJ5yJRi9VDkpsYZXzYdwYpGnLmtDL",
+  "3BpXnfJaUTiwXnJNe7Ej1rcbzqTTQUvLShZaWazebsVR",
+  "5cjcW9wExnJJiqgLjq7DEG75Pm6JBgE1hNv4B2vHXUW6",
+  "EHAAiTxcdDwQ3U4bU6YcMsQGaekdzLS3B5SmYo46kJtL",
+  "5eHhjP8JaYkz83CWwvGU2uMUXefd3AazWGx4gpcuEEYD",
+  "A7hAgCzFw14fejgCp387JUJRMNyz4j89JKnhtKU8piqW"
+].map((value) => new PublicKey(value));
+
+function createTrader() {
+  return new PumpTrader("http://127.0.0.1:8899", bs58.encode(Keypair.generate().secretKey));
+}
+
+function createPoolInfo(isCashbackCoin: boolean) {
+  return {
+    pool: Keypair.generate().publicKey,
+    poolAuthority: Keypair.generate().publicKey,
+    poolKeys: {
+      baseMint: Keypair.generate().publicKey,
+      quoteMint: SOL_MINT,
+      poolBaseTokenAccount: Keypair.generate().publicKey,
+      poolQuoteTokenAccount: Keypair.generate().publicKey,
+      coinCreator: Keypair.generate().publicKey,
+      isCashbackCoin
+    },
+    globalConfig: {
+      address: Keypair.generate().publicKey,
+      protocolFeeRecipients: FEE_RECIPIENTS
+    }
+  };
+}
+
+test("bonding buy appends mutable fee recipient after bondingCurveV2", () => {
+  const trader = createTrader() as any;
+  const bondingCurveV2 = Keypair.generate().publicKey;
+  const feeRecipient = FEE_RECIPIENTS[0];
+
+  const keys = trader.buildBondingBuyKeys({
+    global: Keypair.generate().publicKey,
+    globalFeeRecipient: Keypair.generate().publicKey,
+    mint: Keypair.generate().publicKey,
+    bonding: Keypair.generate().publicKey,
+    associatedBondingCurve: Keypair.generate().publicKey,
+    userAta: Keypair.generate().publicKey,
+    wallet: Keypair.generate().publicKey,
+    creatorVault: Keypair.generate().publicKey,
+    eventAuthority: Keypair.generate().publicKey,
+    pumpProgram: Keypair.generate().publicKey,
+    globalVolumeAccumulator: Keypair.generate().publicKey,
+    userVolumeAccumulator: Keypair.generate().publicKey,
+    feeConfig: Keypair.generate().publicKey,
+    feeProgram: Keypair.generate().publicKey,
+    bondingCurveV2,
+    feeRecipient
+  });
+
+  assert.equal(keys.length, 18);
+  assert.equal(keys.at(-2).pubkey.toBase58(), bondingCurveV2.toBase58());
+  assert.equal(keys.at(-2).isWritable, false);
+  assert.equal(keys.at(-1).pubkey.toBase58(), feeRecipient.toBase58());
+  assert.equal(keys.at(-1).isWritable, true);
+});
+
+test("bonding sell appends mutable fee recipient after optional cashback and bondingCurveV2", () => {
+  const trader = createTrader() as any;
+  const baseArgs = {
+    global: Keypair.generate().publicKey,
+    globalFeeRecipient: Keypair.generate().publicKey,
+    mint: Keypair.generate().publicKey,
+    bonding: Keypair.generate().publicKey,
+    associatedBondingCurve: Keypair.generate().publicKey,
+    userAta: Keypair.generate().publicKey,
+    wallet: Keypair.generate().publicKey,
+    creatorVault: Keypair.generate().publicKey,
+    eventAuthority: Keypair.generate().publicKey,
+    pumpProgram: Keypair.generate().publicKey,
+    feeConfig: Keypair.generate().publicKey,
+    feeProgram: Keypair.generate().publicKey,
+    bondingCurveV2: Keypair.generate().publicKey,
+    feeRecipient: FEE_RECIPIENTS[0],
+    userVolumeAccumulator: Keypair.generate().publicKey
+  };
+
+  const nonCashback = trader.buildBondingSellKeys({
+    ...baseArgs,
+    isCashbackCoin: false
+  });
+  assert.equal(nonCashback.length, 16);
+  assert.equal(nonCashback.at(-2).pubkey.toBase58(), baseArgs.bondingCurveV2.toBase58());
+  assert.equal(nonCashback.at(-1).pubkey.toBase58(), baseArgs.feeRecipient.toBase58());
+  assert.equal(nonCashback.at(-1).isWritable, true);
+
+  const cashback = trader.buildBondingSellKeys({
+    ...baseArgs,
+    isCashbackCoin: true
+  });
+  assert.equal(cashback.length, 17);
+  assert.equal(cashback.at(-3).pubkey.toBase58(), baseArgs.userVolumeAccumulator.toBase58());
+  assert.equal(cashback.at(-2).pubkey.toBase58(), baseArgs.bondingCurveV2.toBase58());
+  assert.equal(cashback.at(-1).pubkey.toBase58(), baseArgs.feeRecipient.toBase58());
+});
+
+test("amm buy places poolV2 before fee recipient pair for non-cashback coins", () => {
+  const trader = createTrader();
+  const poolInfo = createPoolInfo(false);
+  const userBaseAta = Keypair.generate().publicKey;
+  const userQuoteAta = Keypair.generate().publicKey;
+
+  const instruction = trader.createAmmBuyInstruction(
+    poolInfo as any,
+    userBaseAta,
+    userQuoteAta,
+    1n,
+    2n,
+    TOKEN_PROGRAM_ID
+  );
+
+  const feeRecipient = poolInfo.globalConfig.protocolFeeRecipients[0];
+  const feeRecipientAta = getAssociatedTokenAddressSync(
+    SOL_MINT,
+    feeRecipient,
+    true,
+    TOKEN_PROGRAM_ID,
+    ASSOCIATED_TOKEN_PROGRAM_ID
+  );
+
+  assert.equal(instruction.keys.length, 26);
+  assert.equal(instruction.keys.at(-3)?.pubkey.toBase58(), trader.deriveAmmPoolV2(poolInfo.poolKeys.baseMint).toBase58());
+  assert.equal(instruction.keys.at(-2)?.pubkey.toBase58(), feeRecipient.toBase58());
+  assert.equal(instruction.keys.at(-2)?.isWritable, false);
+  assert.equal(instruction.keys.at(-1)?.pubkey.toBase58(), feeRecipientAta.toBase58());
+  assert.equal(instruction.keys.at(-1)?.isWritable, true);
+});
+
+test("amm buy places cashback account before poolV2 and fee recipient tail", () => {
+  const trader = createTrader();
+  const poolInfo = createPoolInfo(true);
+
+  const instruction = trader.createAmmBuyInstruction(
+    poolInfo as any,
+    Keypair.generate().publicKey,
+    Keypair.generate().publicKey,
+    1n,
+    2n,
+    TOKEN_PROGRAM_ID
+  );
+
+  assert.equal(instruction.keys.length, 27);
+  assert.equal(instruction.keys.at(-3)?.isWritable, false);
+  assert.equal(instruction.keys.at(-2)?.pubkey.toBase58(), poolInfo.globalConfig.protocolFeeRecipients[0].toBase58());
+  assert.equal(instruction.keys.at(-1)?.isWritable, true);
+});
+
+test("amm sell places poolV2 before fee recipient pair for non-cashback coins", () => {
+  const trader = createTrader();
+  const poolInfo = createPoolInfo(false);
+
+  const instruction = trader.createAmmSellInstruction(
+    poolInfo as any,
+    Keypair.generate().publicKey,
+    Keypair.generate().publicKey,
+    1n,
+    2n,
+    TOKEN_PROGRAM_ID
+  );
+
+  assert.equal(instruction.keys.length, 24);
+  assert.equal(instruction.keys.at(-3)?.pubkey.toBase58(), trader.deriveAmmPoolV2(poolInfo.poolKeys.baseMint).toBase58());
+  assert.equal(instruction.keys.at(-2)?.pubkey.toBase58(), poolInfo.globalConfig.protocolFeeRecipients[0].toBase58());
+  assert.equal(instruction.keys.at(-1)?.isWritable, true);
+});
+
+test("amm sell places cashback accounts before poolV2 and fee recipient tail", () => {
+  const trader = createTrader();
+  const poolInfo = createPoolInfo(true);
+
+  const instruction = trader.createAmmSellInstruction(
+    poolInfo as any,
+    Keypair.generate().publicKey,
+    Keypair.generate().publicKey,
+    1n,
+    2n,
+    TOKEN_PROGRAM_ID
+  );
+
+  assert.equal(instruction.keys.length, 26);
+  assert.equal(instruction.keys.at(-3)?.pubkey.toBase58(), trader.deriveAmmPoolV2(poolInfo.poolKeys.baseMint).toBase58());
+  assert.equal(instruction.keys.at(-2)?.pubkey.toBase58(), poolInfo.globalConfig.protocolFeeRecipients[0].toBase58());
+  assert.equal(instruction.keys.at(-1)?.pubkey.toBase58(), getAssociatedTokenAddressSync(
+    SOL_MINT,
+    poolInfo.globalConfig.protocolFeeRecipients[0],
+    true,
+    TOKEN_PROGRAM_ID,
+    ASSOCIATED_TOKEN_PROGRAM_ID
+  ).toBase58());
+  assert.equal(instruction.keys.at(-1)?.isWritable, true);
+});
+
+test("loadBonding parses quote mint from v2 bonding curve accounts", async () => {
+  const trader = createTrader() as any;
+  const mint = Keypair.generate().publicKey;
+  const creator = Keypair.generate().publicKey;
+  const data = Buffer.alloc(115);
+
+  let offset = 8;
+  data.writeBigUInt64LE(11n, offset);
+  offset += 8;
+  data.writeBigUInt64LE(22n, offset);
+  offset += 8;
+  data.writeBigUInt64LE(33n, offset);
+  offset += 8;
+  data.writeBigUInt64LE(44n, offset);
+  offset += 8;
+  data.writeBigUInt64LE(55n, offset);
+  offset += 8;
+  data[offset] = 1;
+  offset += 1;
+  creator.toBuffer().copy(data, offset);
+  offset += 32;
+  USDC_MINT.toBuffer().copy(data, offset);
+  offset += 32;
+  data[offset] = 1;
+  offset += 1;
+  data[offset] = 0;
+
+  trader.connection.getAccountInfo = async () => ({ data });
+
+  const result = await trader.loadBonding(mint);
+
+  assert.equal(result.creator.toBase58(), creator.toBase58());
+  assert.equal(result.state.quoteMint?.toBase58(), USDC_MINT.toBase58());
+  assert.equal(result.state.isMayhemMode, true);
+  assert.equal(result.state.isCashbackCoin, false);
+});
+
+test("getPriceAndStatus uses quote mint decimals for incomplete bonding curves", async () => {
+  const trader = createTrader() as any;
+  trader.loadBonding = async () => ({
+    bonding: Keypair.generate().publicKey,
+    creator: Keypair.generate().publicKey,
+    state: {
+      complete: false,
+      quoteMint: USDC_MINT
+    }
+  });
+  trader.calcSell = () => 1_234_567n;
+  trader.connection.getParsedAccountInfo = async () => ({
+    value: {
+      data: {
+        parsed: {
+          info: {
+            decimals: 6
+          }
+        }
+      }
+    }
+  });
+
+  const result = await trader.getPriceAndStatus(Keypair.generate().publicKey.toBase58());
+
+  assert.equal(result.completed, false);
+  assert.equal(result.price, 1.234567);
+});
+
+test("getPriceAndStatus forwards quote mint to AMM pricing for completed curves", async () => {
+  const trader = createTrader() as any;
+  const calls: PublicKey[][] = [];
+
+  trader.loadBonding = async () => ({
+    bonding: Keypair.generate().publicKey,
+    creator: Keypair.generate().publicKey,
+    state: {
+      complete: true,
+      quoteMint: USDC_MINT
+    }
+  });
+  trader.getAmmPrice = async (...args: PublicKey[]) => {
+    calls.push(args);
+    return 0.42;
+  };
+
+  const result = await trader.getPriceAndStatus(Keypair.generate().publicKey.toBase58());
+
+  assert.equal(result.completed, true);
+  assert.equal(result.price, 0.42);
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0][1]?.toBase58(), USDC_MINT.toBase58());
+});