Release sol-trade-sdk 4.0.14

Sync Pump program IDLs with the latest definitions.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sol-trade-sdk"
-version = "4.0.9"
+version = "4.0.14"
 edition = "2021"
 authors = [
     "William <byteblock6@gmail.com>",

README.md

@@ -81,7 +81,7 @@ This SDK is available in multiple languages:
 
 ## ✨ Features
 
-1. **PumpFun Trading**: Support for `buy`, `sell`, `buy_exact_sol_in`, and the new unified `buy_v2`/`sell_v2`/`buy_exact_quote_in_v2` instructions (SOL + USDC)
+1. **PumpFun Trading**: Unified SDK-side `buy`, `sell`, and `buy_exact_quote_in` flow, selecting legacy or V2 on-chain instructions as needed (SOL + USDC)
 2. **PumpSwap Trading**: Support for PumpSwap pool trading operations
 3. **Bonk Trading**: Support for Bonk trading operations
 4. **Raydium CPMM Trading**: Support for Raydium CPMM (Concentrated Pool Market Maker) trading operations
@@ -108,14 +108,14 @@ Add the dependency to your `Cargo.toml`:
 
 ```toml
 # Add to your Cargo.toml
-sol-trade-sdk = { path = "./sol-trade-sdk", version = "4.0.9" }
+sol-trade-sdk = { path = "./sol-trade-sdk", version = "4.0.14" }
 ```
 
 ### Use crates.io
 
 ```toml
 # Add to your Cargo.toml
-sol-trade-sdk = "4.0.9"
+sol-trade-sdk = "4.0.14"
 ```
 
 ## 🛠️ Usage Examples
@@ -152,7 +152,6 @@ let trade_config = TradeConfig::builder(rpc_url, swqos_configs, commitment)
     // .check_min_tip(false)               // default: false - filter SWQOS below min tip
     // .swqos_cores_from_end(false)        // default: false - bind SWQOS to last N CPU cores
     // .mev_protection(false)              // default: false - MEV (Astralane QUIC :9000 or HTTP mev-protect / BlockRazor)
-    // .use_pumpfun_v2(false)             // default: false - V1 (18 accounts); set true for V2 (27 accounts, quote_mint) when PumpFun deploys V2
     .build();
 
 // Create TradingClient
@@ -335,7 +334,7 @@ PumpFun and PumpSwap support **cashback** for eligible tokens: part of the tradi
 
 - **When params come from RPC**: If you use `PumpFunParams::from_mint_by_rpc` or `PumpSwapParams::from_pool_address_by_rpc` / `from_mint_by_rpc`, the SDK reads `is_cashback_coin` from chain—no extra step.
 - **When params come from event/parser**: If you build params from trade events (e.g. [sol-parser-sdk](https://github.com/0xfnzero/sol-parser-sdk)), you **must** pass the cashback flag into the SDK:
-  - **PumpFun**: `PumpFunParams::from_trade(..., is_cashback_coin)` and `PumpFunParams::from_dev_trade(..., is_cashback_coin)` take an `is_cashback_coin` parameter. Set it from the parsed event (e.g. CreateEvent’s `is_cashback_enabled` or BondingCurve’s `is_cashback_coin`).
+  - **PumpFun**: `PumpFunParams::from_trade(..., mint, quote_mint, creator, ..., is_cashback_coin, mayhem_mode)` and `PumpFunParams::from_dev_trade(..., is_cashback_coin)` take an `is_cashback_coin` parameter. Set it from the parsed event (e.g. CreateEvent’s `is_cashback_enabled` or BondingCurve’s `is_cashback_coin`).
   - **PumpSwap**: `PumpSwapParams` has a field `is_cashback_coin`. When constructing params manually (e.g. from pool/trade events), set it from the parsed pool or event data.
 - The **pumpfun_copy_trading** and **pumpfun_sniper_trading** examples use sol-parser-sdk for gRPC subscription and pass `e.is_cashback_coin` when building params.
 - **Claim**: Use `client.claim_cashback_pumpfun()` and `client.claim_cashback_pumpswap(...)` to claim accumulated cashback.
@@ -355,7 +354,7 @@ Some PumpFun coins use **Creator Rewards Sharing**, so the on-chain `creator_vau
 
 The SDK does not fetch creator_vault from RPC on every sell (to avoid latency); pass the up-to-date vault from gRPC/events when available.
 
-#### PumpFun V1 vs V2 Instructions
+#### PumpFun Unified Buy/Sell With V1/V2 Instructions
 
 PumpFun has two instruction sets for bonding-curve trading:
 
@@ -366,38 +365,49 @@ PumpFun has two instruction sets for bonding-curve trading:
 | Quote mint | SOL only (legacy) | SOL or USDC (via `quote_mint` field) |
 | Transaction size | Smaller (fits `PACKET_DATA_SIZE` without LUT) | Larger (requires LUT for most transactions) |
 
-**Default: V1** (`use_pumpfun_v2 = false`). The SDK uses V1 instructions which produce smaller transactions that fit within the 1232-byte `PACKET_DATA_SIZE` limit without requiring an Address Lookup Table.
+The SDK-side builder is version-neutral: callers use the normal buy/sell flow, and `quote_mint` selects the correct on-chain discriminator and account layout internally. There is no user-facing V2 switch required.
+
+**Default: V1**. When `quote_mint` is `Pubkey::default()` or the Solscan SOL sentinel (`So11111111111111111111111111111111111111111`), the SDK uses V1 instructions which produce smaller transactions that fit within the 1232-byte `PACKET_DATA_SIZE` limit without requiring an Address Lookup Table. Passing `WSOL_TOKEN_ACCOUNT` selects SOL V2; passing USDC selects USDC V2.
 
 **Key changes in v2 instructions:**
 - `quote_mint` parameter — pass wrapped SOL for SOL-paired, or USDC mint for USDC-paired
 - 27 fixed accounts (buy) / 26 fixed accounts (sell) — **no optional accounts**
 - `buyback_fee_recipient`, `sharing_config`, and 6 `associated_quote_*` ATAs are now mandatory
 - Same pricing and cost as legacy instructions for SOL-paired coins
+- USDC-paired coins must be bought with USDC and sell back to USDC. The SDK rejects SOL input for USDC quote pools before transaction submission.
 
-**How to enable V2:**
+**Pass `quote_mint` into `PumpFunParams::from_trade`**:
 
-**Method 1 — Global runtime flag** (recommended when PumpFun officially deploys V2 on mainnet):
+When using event/parser data, pass the event's `quote_mint` right after `mint`. `Pubkey::default()` and Solscan SOL (`So11111111111111111111111111111111111111111`) mean the legacy SOL layout; `WSOL_TOKEN_ACCOUNT` means SOL V2; USDC means USDC V2.
 
 ```rust
-let trade_config = TradeConfig::builder(rpc_url, swqos_configs, commitment)
-    .use_pumpfun_v2(true)  // Switch all PumpFun trades to V2 instructions (27 accounts)
-    .build();
+// quote_mint is not a PDA. It is the quote SPL mint carried by parser/gRPC events:
+// - Legacy SOL pool: Pubkey::default() or Solscan SOL from parser data
+// - SOL V2 pool: WSOL_TOKEN_ACCOUNT
+// - USDC V2 pool: USDC mint
+let quote_mint = e.quote_mint;
+let params = PumpFunParams::from_trade(
+    e.bonding_curve,
+    e.associated_bonding_curve,
+    e.mint,
+    quote_mint,
+    e.creator,
+    e.creator_vault,
+    e.virtual_token_reserves,
+    e.virtual_quote_reserves,
+    e.real_token_reserves,
+    e.real_quote_reserves,
+    close_token_account_when_sell,
+    e.fee_recipient,
+    e.token_program,
+    e.is_cashback_coin,
+    Some(e.mayhem_mode),
+);
 ```
 
-**Method 2 — Per-trade via `quote_mint`** (for USDC-paired coins or mixed V1/V2 scenarios):
-
-```rust
-use sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT;
-use sol_trade_sdk::constants::USDC_TOKEN_ACCOUNT;
-
-// SOL-paired coin with v2 layout
-let params = PumpFunParams::from_trade(/* ... */)
-    .with_quote_mint(WSOL_TOKEN_ACCOUNT);
-
-// USDC-paired coin (requires v2)
-let params = PumpFunParams::from_trade(/* ... */)
-    .with_quote_mint(USDC_TOKEN_ACCOUNT);
-```
+For USDC-paired coins, pass `USDC_TOKEN_ACCOUNT` as the buy `input_mint` and sell `output_mint`; SOL/WSOL is only valid for SOL-paired PumpFun curves.
+When consuming parser events, map `quoteMint`, `virtualQuoteReserves`, and `realQuoteReserves` into `PumpFunParams::from_trade(...)`; USDC pools use `4_292_000_000` as the initial virtual quote reserve.
+For legacy SOL events where `quote_mint` is `Pubkey::default()` or Solscan SOL, use `virtual_sol_reserves` / `real_sol_reserves` when the quote-reserve fields are absent or zero.
 
 > **Note**: V2 transactions with ATA creation + durable nonce may exceed `PACKET_DATA_SIZE`. Enable an Address Lookup Table (`address_lookup_table_account`) when using V2.
 

README_CN.md

@@ -81,7 +81,7 @@
 
 ## ✨ 项目特性
 
-1. **PumpFun 交易**: 支持 `buy`、`sell`、`buy_exact_sol_in` 以及全新的统一化 `buy_v2`/`sell_v2`/`buy_exact_quote_in_v2` 指令（SOL + USDC）
+1. **PumpFun 交易**: SDK 侧统一为 `buy`、`sell`、`buy_exact_quote_in` 流程，内部按需选择旧版或 V2 链上指令（SOL + USDC）
 2. **PumpSwap 交易**: 支持 PumpSwap 池的交易操作
 3. **Bonk 交易**: 支持 Bonk 的交易操作
 4. **Raydium CPMM 交易**: 支持 Raydium CPMM (Concentrated Pool Market Maker) 的交易操作
@@ -108,14 +108,14 @@ git clone https://github.com/0xfnzero/sol-trade-sdk
 
 ```toml
 # 添加到您的 Cargo.toml
-sol-trade-sdk = { path = "./sol-trade-sdk", version = "4.0.9" }
+sol-trade-sdk = { path = "./sol-trade-sdk", version = "4.0.14" }
 ```
 
 ### 使用 crates.io
 
 ```toml
 # 添加到您的 Cargo.toml
-sol-trade-sdk = "4.0.9"
+sol-trade-sdk = "4.0.14"
 ```
 
 ## 🛠️ 使用示例
@@ -333,7 +333,7 @@ PumpFun 与 PumpSwap 支持**返现（Cashback）**：部分手续费可返还
 
 - **参数来自 RPC 时**：使用 `PumpFunParams::from_mint_by_rpc` 或 `PumpSwapParams::from_pool_address_by_rpc` / `from_mint_by_rpc` 时，SDK 会从链上读取 `is_cashback_coin`，无需额外传入。
 - **参数来自事件/解析器时**：若根据交易事件（如 [sol-parser-sdk](https://github.com/0xfnzero/sol-parser-sdk)）构建参数，**必须**把返现标志传给 SDK：
-  - **PumpFun**：`PumpFunParams::from_trade(..., is_cashback_coin)` 与 `PumpFunParams::from_dev_trade(..., is_cashback_coin)` 最后一个参数为 `is_cashback_coin`。从解析出的事件传入（如 sol-parser-sdk 的 `PumpFunTradeEvent.is_cashback_coin`）。
+  - **PumpFun**：`PumpFunParams::from_trade(..., mint, quote_mint, creator, ..., is_cashback_coin, mayhem_mode)` 与 `PumpFunParams::from_dev_trade(..., is_cashback_coin)` 都需要传入 `is_cashback_coin`。从解析出的事件传入（如 sol-parser-sdk 的 `PumpFunTradeEvent.is_cashback_coin`）。
   - **PumpSwap**：`PumpSwapParams` 有字段 `is_cashback_coin`。手动构造参数（如从池/交易事件）时，从解析到的池或事件数据中设置该字段。
 - **pumpfun_copy_trading**、**pumpfun_sniper_trading** 示例使用 sol-parser-sdk 订阅 gRPC 事件，并在构造参数时传入 `e.is_cashback_coin`。
 - **领取返现**：使用 `client.claim_cashback_pumpfun()` 和 `client.claim_cashback_pumpswap(...)` 领取累计的返现。
@@ -360,10 +360,12 @@ SDK 不会在每次卖出时通过 RPC 拉取 creator_vault（以避免延迟）
 - **sol-parser-sdk**：指令解析从账户 17、18 写入；若事件来自日志，账户填充器也会从指令补全。用 `PumpSwapParams::from_trade(..., e.coin_creator_vault_ata, e.coin_creator_vault_authority, ...)` 即可。
 - **solana-streamer**：指令解析从 `accounts.get(17)`、`accounts.get(18)` 写入。同样用事件的 `coin_creator_vault_ata`、`coin_creator_vault_authority` 调用 `from_trade`。
 
-### Pump.fun Bonding Curve v2（buy_v2 / sell_v2 / buy_exact_quote_in_v2）
+### Pump.fun Bonding Curve 统一买卖入口与 v2 指令
 
 Pump.fun 已升级 Bonding Curve 合约，推出**统一化 v2 指令**，通过固定账户布局同时支持 SOL 和 USDC 配对币。旧版 `buy`/`sell`/`buy_exact_sol_in` 仍可用于 SOL 配对币，且保持为默认选项。
 
+SDK 侧调用入口保持统一：正常使用 `buy` / `sell` 流程即可，SDK 会根据 `quote_mint` 自动选择正确的链上 discriminator 和账户布局。
+
 **v2 指令关键变化：**
 - 新增 `quote_mint` 参数 — SOL 配对传包装 SOL（`So11111111111111111111111111111111111111112`），USDC 配对传 USDC mint
 - 27 个固定账户（buy）/ 26 个固定账户（sell）— **无可选账户**
@@ -372,30 +374,46 @@ Pump.fun 已升级 Bonding Curve 合约，推出**统一化 v2 指令**，通过
 
 **使用方式：**
 
-设置 `PumpFunParams` 的 `quote_mint` 即可，SDK 会自动切换到 v2 discriminator 和新账户布局：
+把事件里的 `quote_mint` 传给 `PumpFunParams::from_trade`。`quote_mint` 不是 PDA，它就是 quote SPL mint；`Pubkey::default()` 和 Solscan SOL（`So11111111111111111111111111111111111111111`）表示旧版 SOL 布局，`WSOL_TOKEN_ACCOUNT` 表示 SOL V2，USDC 表示 USDC V2：
 
 ```rust
-use sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT;
-use sol_trade_sdk::constants::USDC_TOKEN_ACCOUNT;
+// legacy SOL 池：log 事件里可能是 Pubkey::default()，parser 数据里是 Solscan SOL sentinel
+// SOL V2 池：WSOL_TOKEN_ACCOUNT
+// USDC 池：就是 USDC mint
+let quote_mint = e.quote_mint;
 
-// SOL 配对币 — 传包装 SOL mint
-let params = PumpFunParams::from_trade(/* ... */)
-    .with_quote_mint(WSOL_TOKEN_ACCOUNT);
-
-// USDC 配对币（即将开放 — 必须使用 v2）
-let params = PumpFunParams::from_trade(/* ... */)
-    .with_quote_mint(USDC_TOKEN_ACCOUNT);
+let params = PumpFunParams::from_trade(
+    e.bonding_curve,
+    e.associated_bonding_curve,
+    e.mint,
+    quote_mint,
+    e.creator,
+    e.creator_vault,
+    e.virtual_token_reserves,
+    e.virtual_quote_reserves,
+    e.real_token_reserves,
+    e.real_quote_reserves,
+    close_token_account_when_sell,
+    e.fee_recipient,
+    e.token_program,
+    e.is_cashback_coin,
+    Some(e.mayhem_mode),
+);
 
 // 之后正常交易
 client.buy(buy_params).await?;
 client.sell(sell_params).await?;
 ```
 
-| quote_mint | use_v2_ix | 实际使用的指令 | 说明 |
-|-----------|-------------|---------|------|
-| 未设置（默认） | `false` | 旧版 `buy`/`sell`/`buy_exact_sol_in` | 向后兼容，仅 SOL |
-| `WSOL_TOKEN_ACCOUNT` | `true` | `buy_v2`/`sell_v2`/`buy_exact_quote_in_v2` | SOL 配对，统一布局 |
-| `USDC_TOKEN_ACCOUNT` | `true` | `buy_v2`/`sell_v2`/`buy_exact_quote_in_v2` | USDC 配对（必须使用 v2） |
+USDC 配对币必须用 USDC 买入、卖出也结算为 USDC；SOL/WSOL 只适用于 SOL 配对的 PumpFun 曲线。SDK 会在提交前拒绝 USDC quote 池的 SOL 输入，避免链上 6063 失败。
+消费 parser 事件时，需要把 `quoteMint`、`virtualQuoteReserves`、`realQuoteReserves` 传进 `PumpFunParams::from_trade(...)`；USDC 池初始虚拟 quote reserve 是 `4_292_000_000`。
+legacy SOL 事件里如果 `quote_mint` 是默认值或 Solscan SOL，并且 quote reserve 字段缺失/为 0，应回退使用 `virtual_sol_reserves` / `real_sol_reserves`。
+
+| quote_mint | 实际使用的指令 | 说明 |
+|-----------|---------|------|
+| 未设置（默认）/ `SOL_TOKEN_ACCOUNT` (`So111...11111`) | 旧版 `buy`/`sell`/`buy_exact_sol_in` | 向后兼容，仅 SOL |
+| `WSOL_TOKEN_ACCOUNT` (`So111...11112`) | `buy_v2`/`sell_v2`/`buy_exact_quote_in_v2` | SOL 配对，统一布局 |
+| `USDC_TOKEN_ACCOUNT` | `buy_v2`/`sell_v2`/`buy_exact_quote_in_v2` | USDC 配对（必须使用 v2） |
 
 ## 🛡️ MEV 保护服务
 

examples/address_lookup/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-sol-parser-sdk = "0.2.2"
+sol-parser-sdk = "0.4.14"
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/address_lookup/src/main.rs

@@ -130,6 +130,16 @@ async fn pumpfun_copy_trade_with_grpc(
 
     let client = create_solana_trade_client().await?;
     let mint_pubkey = trade_info.mint;
+    let virtual_quote_reserves = if trade_info.virtual_quote_reserves != 0 {
+        trade_info.virtual_quote_reserves
+    } else {
+        trade_info.virtual_sol_reserves
+    };
+    let real_quote_reserves = if trade_info.virtual_quote_reserves != 0 {
+        trade_info.real_quote_reserves
+    } else {
+        trade_info.real_sol_reserves
+    };
     let slippage_basis_points = Some(100);
     let recent_blockhash = client.infrastructure.rpc.get_latest_blockhash().await?;
 
@@ -154,12 +164,13 @@ async fn pumpfun_copy_trade_with_grpc(
             trade_info.bonding_curve,
             trade_info.associated_bonding_curve,
             trade_info.mint,
+            trade_info.quote_mint,
             trade_info.creator,
             trade_info.creator_vault,
             trade_info.virtual_token_reserves,
-            trade_info.virtual_sol_reserves,
+            virtual_quote_reserves,
             trade_info.real_token_reserves,
-            trade_info.real_sol_reserves,
+            real_quote_reserves,
             None,
             trade_info.fee_recipient,
             trade_info.token_program,

examples/nonce_cache/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-sol-parser-sdk = "0.2.2"
+sol-parser-sdk = "0.4.14"
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 spl-associated-token-account = "7.0.0"

examples/nonce_cache/src/main.rs

@@ -129,6 +129,16 @@ async fn pumpfun_copy_trade_with_grpc(
 
     let client = create_solana_trade_client().await?;
     let mint_pubkey = trade_info.mint;
+    let virtual_quote_reserves = if trade_info.virtual_quote_reserves != 0 {
+        trade_info.virtual_quote_reserves
+    } else {
+        trade_info.virtual_sol_reserves
+    };
+    let real_quote_reserves = if trade_info.virtual_quote_reserves != 0 {
+        trade_info.real_quote_reserves
+    } else {
+        trade_info.real_sol_reserves
+    };
     let slippage_basis_points = Some(100);
     let recent_blockhash = client.infrastructure.rpc.get_latest_blockhash().await?;
 
@@ -150,12 +160,13 @@ async fn pumpfun_copy_trade_with_grpc(
             trade_info.bonding_curve,
             trade_info.associated_bonding_curve,
             trade_info.mint,
+            trade_info.quote_mint,
             trade_info.creator,
             trade_info.creator_vault,
             trade_info.virtual_token_reserves,
-            trade_info.virtual_sol_reserves,
+            virtual_quote_reserves,
             trade_info.real_token_reserves,
-            trade_info.real_sol_reserves,
+            real_quote_reserves,
             None,
             trade_info.fee_recipient,
             trade_info.token_program,

examples/pumpfun_copy_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-sol-parser-sdk = "0.2.2"
+sol-parser-sdk = "0.4.14"
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/pumpfun_copy_trading/src/main.rs

@@ -128,6 +128,13 @@ async fn create_solana_trade_client() -> AnyResult<SolanaTrade> {
 async fn pumpfun_copy_trade(e: sol_parser_sdk::core::events::PumpFunTradeEvent) -> AnyResult<()> {
     let client = create_solana_trade_client().await?;
     let mint_pubkey = e.mint;
+    let virtual_quote_reserves = if e.virtual_quote_reserves != 0 {
+        e.virtual_quote_reserves
+    } else {
+        e.virtual_sol_reserves
+    };
+    let real_quote_reserves =
+        if e.virtual_quote_reserves != 0 { e.real_quote_reserves } else { e.real_sol_reserves };
     let slippage_basis_points = Some(100u64);
     let recent_blockhash = client.infrastructure.rpc.get_latest_blockhash().await?;
 
@@ -147,12 +154,13 @@ async fn pumpfun_copy_trade(e: sol_parser_sdk::core::events::PumpFunTradeEvent)
             e.bonding_curve,
             e.associated_bonding_curve,
             e.mint,
+            e.quote_mint,
             e.creator,
             e.creator_vault,
             e.virtual_token_reserves,
-            e.virtual_sol_reserves,
+            virtual_quote_reserves,
             e.real_token_reserves,
-            e.real_sol_reserves,
+            real_quote_reserves,
             None,
             e.fee_recipient,
             e.token_program,
@@ -197,12 +205,13 @@ async fn pumpfun_copy_trade(e: sol_parser_sdk::core::events::PumpFunTradeEvent)
             e.bonding_curve,
             e.associated_bonding_curve,
             e.mint,
+            e.quote_mint,
             e.creator,
             e.creator_vault,
             e.virtual_token_reserves,
-            e.virtual_sol_reserves,
+            virtual_quote_reserves,
             e.real_token_reserves,
-            e.real_sol_reserves,
+            real_quote_reserves,
             Some(true),
             e.fee_recipient,
             e.token_program,

examples/pumpfun_sniper_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-sol-parser-sdk = "0.2.2"
+sol-parser-sdk = "0.4.14"
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/pumpfun_sniper_trading/src/main.rs

@@ -118,6 +118,13 @@ async fn create_solana_trade_client() -> AnyResult<SolanaTrade> {
 async fn pumpfun_sniper_trade(e: sol_parser_sdk::core::events::PumpFunTradeEvent) -> AnyResult<()> {
     let client = create_solana_trade_client().await?;
     let mint_pubkey = e.mint;
+    let virtual_quote_reserves = if e.virtual_quote_reserves != 0 {
+        e.virtual_quote_reserves
+    } else {
+        e.virtual_sol_reserves
+    };
+    let real_quote_reserves =
+        if e.virtual_quote_reserves != 0 { e.real_quote_reserves } else { e.real_sol_reserves };
     let slippage_basis_points = Some(300u64);
     let recent_blockhash = client.infrastructure.rpc.get_latest_blockhash().await?;
 
@@ -181,12 +188,13 @@ async fn pumpfun_sniper_trade(e: sol_parser_sdk::core::events::PumpFunTradeEvent
             e.bonding_curve,
             e.associated_bonding_curve,
             e.mint,
+            e.quote_mint,
             e.creator,
             e.creator_vault,
             e.virtual_token_reserves,
-            e.virtual_sol_reserves,
+            virtual_quote_reserves,
             e.real_token_reserves,
-            e.real_sol_reserves,
+            real_quote_reserves,
             Some(true),
             e.fee_recipient,
             e.token_program,

idl/README.md

@@ -1,14 +1,16 @@
-# IDL sources
+# IDL files
 
-Bitquery IDLs synced from `bitquery/solana-idl-lib` commit `f804b17`.
+Supported DEX IDLs are stored directly in this directory. The files below were
+synced from `bitquery/solana-idl-lib` commit `f804b17` and written to the SDK's
+canonical local filenames.
 
-| SDK protocol | Root IDL | Bitquery source |
+| SDK protocol | Local IDL | Source path |
 | --- | --- | --- |
-| Bonk / Raydium Launchpad | `bonk.json` | `bitquery/raydium/launchpad.json` |
-| Raydium CPMM | `raydium_cpmm.json` | `bitquery/raydium/raydium_cp.json` |
-| Raydium AMM v4 | `raydium_amm_v4.json` | `bitquery/raydium/raydium_amm.json` |
-| Meteora DAMM v2 | `meteora_damm_v2.json` | `bitquery/meteora/cp_amm_016.json` |
-| PumpFun | `pump.json` | `bitquery/pumpfun/pump.json` |
-| PumpSwap | `pump_amm.json` | `bitquery/pumpswap/amm.json` |
+| Bonk / Raydium Launchpad | `bonk.json` | `raydium/launchpad.json` |
+| Raydium CPMM | `raydium_cpmm.json` | `raydium/raydium_cp.json` |
+| Raydium AMM v4 | `raydium_amm_v4.json` | `raydium/raydium_amm.json` |
+| Meteora DAMM v2 | `meteora_damm_v2.json` | `meteora/cp_amm_016.json` |
+| PumpFun | `pump.json` | `pumpfun/pump.json` |
+| PumpSwap | `pump_amm.json` | `pumpswap/amm.json` |
 
-The root PumpFun/PumpSwap IDLs remain the newer local copies used for cashback and v2 instruction parity. The Bitquery snapshots are kept under `idl/bitquery/` for source comparison.
+No separate source snapshot tree is kept in the repository.

idl/pump.json

@@ -1943,6 +1943,117 @@
       ],
       "args": []
     },
+    {
+      "name": "collect_creator_fee_v2",
+      "docs": [
+        "Collects creator_fee from creator_vault to the coin creator account"
+      ],
+      "discriminator": [207, 17, 138, 242, 4, 34, 19, 56],
+      "accounts": [
+        {
+          "name": "creator",
+          "writable": true
+        },
+        {
+          "name": "creator_token_account",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "account",
+                "path": "creator"
+              },
+              {
+                "kind": "account",
+                "path": "quote_token_program"
+              },
+              {
+                "kind": "account",
+                "path": "quote_mint"
+              }
+            ],
+            "program": {
+              "kind": "account",
+              "path": "associated_token_program"
+            }
+          }
+        },
+        {
+          "name": "creator_vault",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  99, 114, 101, 97, 116, 111, 114, 45, 118, 97, 117, 108, 116
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "creator"
+              }
+            ]
+          }
+        },
+        {
+          "name": "creator_vault_token_account",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "account",
+                "path": "creator_vault"
+              },
+              {
+                "kind": "account",
+                "path": "quote_token_program"
+              },
+              {
+                "kind": "account",
+                "path": "quote_mint"
+              }
+            ],
+            "program": {
+              "kind": "account",
+              "path": "associated_token_program"
+            }
+          }
+        },
+        {
+          "name": "quote_mint"
+        },
+        {
+          "name": "quote_token_program"
+        },
+        {
+          "name": "associated_token_program",
+          "address": "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        },
+        {
+          "name": "event_authority",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  95, 95, 101, 118, 101, 110, 116, 95, 97, 117, 116, 104, 111,
+                  114, 105, 116, 121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "program"
+        }
+      ],
+      "args": []
+    },
     {
       "name": "create",
       "docs": ["Creates a new coin and bonding curve."],
@@ -2446,6 +2557,153 @@
         }
       }
     },
+    {
+      "name": "distribute_creator_fees_v2",
+      "discriminator": [255, 203, 19, 79, 244, 68, 8, 159],
+      "accounts": [
+        {
+          "name": "payer",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "mint",
+          "relations": ["sharing_config"]
+        },
+        {
+          "name": "bonding_curve",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  98, 111, 110, 100, 105, 110, 103, 45, 99, 117, 114, 118, 101
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "mint"
+              }
+            ]
+          }
+        },
+        {
+          "name": "sharing_config",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  115, 104, 97, 114, 105, 110, 103, 45, 99, 111, 110, 102, 105,
+                  103
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "mint"
+              }
+            ],
+            "program": {
+              "kind": "const",
+              "value": [
+                12, 53, 255, 169, 5, 90, 142, 86, 141, 168, 247, 188, 7, 86, 21,
+                39, 76, 241, 201, 44, 164, 31, 64, 0, 156, 81, 106, 164, 20,
+                194, 124, 112
+              ]
+            }
+          }
+        },
+        {
+          "name": "creator_vault",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  99, 114, 101, 97, 116, 111, 114, 45, 118, 97, 117, 108, 116
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "bonding_curve.creator",
+                "account": "BondingCurve"
+              }
+            ]
+          }
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        },
+        {
+          "name": "event_authority",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  95, 95, 101, 118, 101, 110, 116, 95, 97, 117, 116, 104, 111,
+                  114, 105, 116, 121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "program",
+          "address": "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"
+        },
+        {
+          "name": "creator_vault_quote_token_account",
+          "docs": [
+            "Deserialized manually in the handler for non-legacy quote mints."
+          ],
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "account",
+                "path": "creator_vault"
+              },
+              {
+                "kind": "account",
+                "path": "quote_token_program"
+              },
+              {
+                "kind": "account",
+                "path": "quote_mint"
+              }
+            ],
+            "program": {
+              "kind": "account",
+              "path": "associated_token_program"
+            }
+          }
+        },
+        {
+          "name": "quote_mint"
+        },
+        {
+          "name": "quote_token_program"
+        },
+        {
+          "name": "associated_token_program",
+          "address": "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        }
+      ],
+      "args": [
+        {
+          "name": "initialize_ata",
+          "type": "bool"
+        }
+      ],
+      "returns": {
+        "defined": {
+          "name": "DistributeCreatorFeesEvent"
+        }
+      }
+    },
     {
       "name": "extend_account",
       "docs": ["Extends the size of program-owned accounts"],
@@ -5256,6 +5514,16 @@
       "code": 6069,
       "name": "QuoteMintNotEligibleForWhitelist",
       "msg": "Quote mint cannot be added or removed via whitelist (default or native SOL mint)"
+    },
+    {
+      "code": 6070,
+      "name": "UnableToDistributeCreatorFeesToUninitializedAccount",
+      "msg": "Unable to distribute creator fees to uninitialized account"
+    },
+    {
+      "code": 6071,
+      "name": "MayhemModeQuoteMintNotAllowed",
+      "msg": "Mayhem mode quote mint not allowed"
     }
   ],
   "types": [
@@ -5495,6 +5763,10 @@
           {
             "name": "creator_fee",
             "type": "u64"
+          },
+          {
+            "name": "quote_mint",
+            "type": "pubkey"
           }
         ]
       }
@@ -5563,6 +5835,10 @@
           {
             "name": "pool",
             "type": "pubkey"
+          },
+          {
+            "name": "quote_mint",
+            "type": "pubkey"
           }
         ]
       }
@@ -5695,6 +5971,10 @@
           {
             "name": "distributed",
             "type": "u64"
+          },
+          {
+            "name": "quote_mint",
+            "type": "pubkey"
           }
         ]
       }
@@ -6517,6 +6797,14 @@
           {
             "name": "total_cashback_claimed",
             "type": "u64"
+          },
+          {
+            "name": "stable_cashback_earned",
+            "type": "u64"
+          },
+          {
+            "name": "total_stable_cashback_claimed",
+            "type": "u64"
           }
         ]
       }

idl/pump_amm.json

@@ -3965,6 +3965,254 @@
       ],
       "args": []
     },
+    {
+      "name": "transfer_creator_fees_to_pump_v2",
+      "discriminator": [
+        1,
+        33,
+        78,
+        185,
+        33,
+        67,
+        44,
+        92
+      ],
+      "accounts": [
+        {
+          "name": "payer",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "quote_mint"
+        },
+        {
+          "name": "token_program"
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        },
+        {
+          "name": "associated_token_program",
+          "address": "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        },
+        {
+          "name": "coin_creator"
+        },
+        {
+          "name": "coin_creator_vault_authority",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  99,
+                  114,
+                  101,
+                  97,
+                  116,
+                  111,
+                  114,
+                  95,
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "coin_creator"
+              }
+            ]
+          }
+        },
+        {
+          "name": "coin_creator_vault_ata",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "account",
+                "path": "coin_creator_vault_authority"
+              },
+              {
+                "kind": "account",
+                "path": "token_program"
+              },
+              {
+                "kind": "account",
+                "path": "quote_mint"
+              }
+            ],
+            "program": {
+              "kind": "const",
+              "value": [
+                140,
+                151,
+                37,
+                143,
+                78,
+                36,
+                137,
+                241,
+                187,
+                61,
+                16,
+                41,
+                20,
+                142,
+                13,
+                131,
+                11,
+                90,
+                19,
+                153,
+                218,
+                255,
+                16,
+                132,
+                4,
+                142,
+                123,
+                216,
+                219,
+                233,
+                248,
+                89
+              ]
+            }
+          }
+        },
+        {
+          "name": "pump_creator_vault",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  99,
+                  114,
+                  101,
+                  97,
+                  116,
+                  111,
+                  114,
+                  45,
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "coin_creator"
+              }
+            ],
+            "program": {
+              "kind": "const",
+              "value": [
+                1,
+                86,
+                224,
+                246,
+                147,
+                102,
+                90,
+                207,
+                68,
+                219,
+                21,
+                104,
+                191,
+                23,
+                91,
+                170,
+                81,
+                137,
+                203,
+                151,
+                245,
+                210,
+                255,
+                59,
+                101,
+                93,
+                43,
+                182,
+                253,
+                109,
+                24,
+                176
+              ]
+            }
+          }
+        },
+        {
+          "name": "pump_creator_vault_ata",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "account",
+                "path": "pump_creator_vault"
+              },
+              {
+                "kind": "account",
+                "path": "token_program"
+              },
+              {
+                "kind": "account",
+                "path": "quote_mint"
+              }
+            ],
+            "program": {
+              "kind": "account",
+              "path": "associated_token_program"
+            }
+          }
+        },
+        {
+          "name": "event_authority",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  95,
+                  95,
+                  101,
+                  118,
+                  101,
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "program"
+        }
+      ],
+      "args": []
+    },
     {
       "name": "update_admin",
       "discriminator": [
@@ -4027,6 +4275,72 @@
       ],
       "args": []
     },
+    {
+      "name": "update_buyback_config",
+      "discriminator": [
+        251,
+        224,
+        171,
+        146,
+        160,
+        26,
+        113,
+        233
+      ],
+      "accounts": [
+        {
+          "name": "admin",
+          "signer": true,
+          "relations": [
+            "global_config"
+          ]
+        },
+        {
+          "name": "global_config",
+          "writable": true
+        },
+        {
+          "name": "event_authority",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  95,
+                  95,
+                  101,
+                  118,
+                  101,
+                  110,
+                  116,
+                  95,
+                  97,
+                  117,
+                  116,
+                  104,
+                  111,
+                  114,
+                  105,
+                  116,
+                  121
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "program"
+        }
+      ],
+      "args": [
+        {
+          "name": "buyback_basis_points",
+          "type": {
+            "option": "u64"
+          }
+        }
+      ]
+    },
     {
       "name": "update_fee_config",
       "discriminator": [
@@ -4835,7 +5149,34 @@
     },
     {
       "code": 6052,
-      "name": "CashbackEarnedDoesNotMatchTokenInVault"
+      "name": "TokensInVaultLessThanCashbackEarned"
+    },
+    {
+      "code": 6053,
+      "name": "BuybackFeeRecipientNotAuthorized",
+      "msg": "Buyback fee recipient not authorized"
+    },
+    {
+      "code": 6054,
+      "name": "AllBuybackFeeRecipientsShouldBeNonZero"
+    },
+    {
+      "code": 6055,
+      "name": "NotUniqueBuybackFeeRecipients"
+    },
+    {
+      "code": 6056,
+      "name": "BuybackBasisPointsOutOfRange",
+      "msg": "buyback_basis_points must be <= 10_000"
+    },
+    {
+      "code": 6057,
+      "name": "WrongBuybackFeeRecipientsCount",
+      "msg": "buyback fee recipients require exactly 8 remaining accounts (or none)"
+    },
+    {
+      "code": 6058,
+      "name": "BuybackFeeRecipientMissing"
     }
   ],
   "types": [
@@ -5086,6 +5427,14 @@
           {
             "name": "cashback",
             "type": "u64"
+          },
+          {
+            "name": "buyback_fee_basis_points",
+            "type": "u64"
+          },
+          {
+            "name": "buyback_fee",
+            "type": "u64"
           }
         ]
       }
@@ -5523,6 +5872,16 @@
                 }
               }
             }
+          },
+          {
+            "name": "stable_fee_tiers",
+            "type": {
+              "vec": {
+                "defined": {
+                  "name": "FeeTier"
+                }
+              }
+            }
           }
         ]
       }
@@ -5646,6 +6005,19 @@
           {
             "name": "is_cashback_enabled",
             "type": "bool"
+          },
+          {
+            "name": "buyback_fee_recipients",
+            "type": {
+              "array": [
+                "pubkey",
+                8
+              ]
+            }
+          },
+          {
+            "name": "buyback_basis_points",
+            "type": "u64"
           }
         ]
       }
@@ -5941,6 +6313,14 @@
           {
             "name": "cashback",
             "type": "u64"
+          },
+          {
+            "name": "buyback_fee_basis_points",
+            "type": "u64"
+          },
+          {
+            "name": "buyback_fee",
+            "type": "u64"
           }
         ]
       }

src/client/mod.rs

@@ -14,6 +14,7 @@ use crate::constants::WSOL_TOKEN_ACCOUNT;
 use crate::swqos::common::TradeError;
 use crate::swqos::SwqosClient;
 use crate::swqos::SwqosConfig;
+use crate::swqos::SwqosType;
 use crate::swqos::TradeType;
 use crate::trading::core::params::BonkParams;
 use crate::trading::core::params::DexParamEnum;
@@ -83,7 +84,7 @@ pub struct TradingInfrastructure {
     pub swqos_clients: Arc<Vec<Arc<SwqosClient>>>,
     /// Configuration used to create this infrastructure
     pub config: InfrastructureConfig,
-    /// Precomputed at init: min(swqos_clients.len(), 2/3 * num_cores). Not computed on trade hot path.
+    /// Precomputed at init: min(max SWQOS submit lanes, 2/3 * num_cores). Not computed on trade hot path.
     pub max_sender_concurrency: usize,
     /// Precomputed at init: first max_sender_concurrency CoreIds for job affinity. Empty if no cores. Not computed on trade hot path.
     pub effective_core_ids: Arc<Vec<core_affinity::CoreId>>,
@@ -225,11 +226,21 @@ impl TradingInfrastructure {
             eprintln!("ℹ️  SWQOS 通道已就绪: {} 条 → [{}]", swqos_clients.len(), labels.join(", "));
         }
 
-        let swqos_count = swqos_clients.len();
+        let max_submit_lanes = swqos_clients
+            .iter()
+            .map(|client| {
+                if matches!(client.get_swqos_type(), SwqosType::Default) {
+                    1usize
+                } else {
+                    2usize
+                }
+            })
+            .sum::<usize>()
+            .max(1);
         let (max_sender_concurrency, effective_core_ids) = {
             let num_cores = core_affinity::get_core_ids().map(|c| c.len()).unwrap_or(0);
             let max_by_cores = (num_cores * 2 / 3).max(1);
-            let cap = swqos_count.min(max_by_cores).max(1);
+            let cap = max_submit_lanes.min(max_by_cores).max(1);
             let ids = core_affinity::get_core_ids()
                 .map(|all| {
                     let v: Vec<_> = all.into_iter().collect();
@@ -301,8 +312,6 @@ pub struct TradingClient {
     pub log_enabled: bool,
     /// Whether to check minimum tip per SWQOS (from TradeConfig.check_min_tip). Default false for lower latency.
     pub check_min_tip: bool,
-    /// Use PumpFun V2 instructions (buy_v2 / sell_v2, 27-account metas). Default false.
-    pub use_pumpfun_v2: bool,
 }
 
 static INSTANCE: Mutex<Option<Arc<TradingClient>>> = Mutex::new(None);
@@ -323,7 +332,6 @@ impl Clone for TradingClient {
             effective_core_ids: self.effective_core_ids.clone(),
             log_enabled: self.log_enabled,
             check_min_tip: self.check_min_tip,
-            use_pumpfun_v2: self.use_pumpfun_v2,
         }
     }
 }
@@ -369,7 +377,7 @@ pub struct TradeBuyParams {
     pub gas_fee_strategy: GasFeeStrategy,
     /// Whether to simulate the transaction instead of executing it
     pub simulate: bool,
-    /// Use exact SOL amount instructions (buy_exact_sol_in for PumpFun, buy_exact_quote_in for PumpSwap).
+    /// Use exact quote-input buy instructions (legacy PumpFun uses SOL quote; V2/PumpSwap use generic quote).
     /// When Some(true) or None (default), the exact SOL/quote amount is spent and slippage is applied to output tokens.
     /// When Some(false), uses regular buy instruction where slippage is applied to SOL/quote input.
     /// This option only applies to PumpFun and PumpSwap DEXes; it is ignored for other DEXes.
@@ -460,7 +468,6 @@ impl TradingClient {
             effective_core_ids,
             log_enabled: true,
             check_min_tip: false,
-            use_pumpfun_v2: false,
         }
     }
 
@@ -507,7 +514,6 @@ impl TradingClient {
             effective_core_ids,
             log_enabled: true,
             check_min_tip: false,
-            use_pumpfun_v2: false,
         }
     }
 
@@ -687,7 +693,6 @@ impl TradingClient {
             effective_core_ids: infrastructure.effective_core_ids.clone(),
             log_enabled: trade_config.log_enabled,
             check_min_tip: trade_config.check_min_tip,
-            use_pumpfun_v2: trade_config.use_pumpfun_v2,
         };
 
         let mut current = INSTANCE.lock();
@@ -713,7 +718,7 @@ impl TradingClient {
 
     /// **Advanced.** Use dedicated OS threads for sender pool (and optionally pin to cores).  
     /// By default the SDK uses a shared tokio pool; this can reduce scheduling contention when sending many txs.  
-    /// Concurrency and core count are capped internally (≤ swqos count, ≤ 2/3 of CPU cores).  
+    /// Concurrency and core count are capped internally (≤ max submit lanes, ≤ 2/3 of CPU cores).
     /// - `None`: keep default (shared tokio pool).  
     /// - `Some(vec![])`: dedicated threads with default count, no core pinning.  
     /// - `Some(indices)`: dedicated threads pinned to those core indices (trimmed to cap).  
@@ -870,12 +875,15 @@ impl TradingClient {
             check_min_tip: self.check_min_tip,
             grpc_recv_us: params.grpc_recv_us,
             use_exact_sol_amount: params.use_exact_sol_amount,
-            use_pumpfun_v2: self.use_pumpfun_v2,
         };
 
         let swap_result = executor.swap(buy_params).await;
         let result = swap_result.map(|(success, sigs, err, timings)| {
-            (success, sigs, err.map(TradeError::from), timings)
+            let legacy_timings = timings
+                .into_iter()
+                .map(|timing| (timing.swqos_type, timing.submit_done_us))
+                .collect();
+            (success, sigs, err.map(TradeError::from), legacy_timings)
         });
         result
     }
@@ -982,12 +990,15 @@ impl TradingClient {
             check_min_tip: self.check_min_tip,
             grpc_recv_us: params.grpc_recv_us,
             use_exact_sol_amount: None,
-            use_pumpfun_v2: self.use_pumpfun_v2,
         };
 
         let swap_result = executor.swap(sell_params).await;
         let result = swap_result.map(|(success, sigs, err, timings)| {
-            (success, sigs, err.map(TradeError::from), timings)
+            let legacy_timings = timings
+                .into_iter()
+                .map(|timing| (timing.swqos_type, timing.submit_done_us))
+                .collect();
+            (success, sigs, err.map(TradeError::from), legacy_timings)
         });
         result
     }

src/common/bonding_curve.rs

@@ -31,7 +31,7 @@ use solana_sdk::pubkey::Pubkey;
 
 use crate::instruction::utils::pumpfun::global_constants::{
     INITIAL_REAL_TOKEN_RESERVES, INITIAL_VIRTUAL_SOL_RESERVES, INITIAL_VIRTUAL_TOKEN_RESERVES,
-    TOKEN_TOTAL_SUPPLY,
+    INITIAL_VIRTUAL_USDC_RESERVES, TOKEN_TOTAL_SUPPLY,
 };
 use crate::instruction::utils::pumpfun::{get_bonding_curve_pda, get_creator_vault_pda};
 
@@ -62,9 +62,57 @@ pub struct BondingCurveAccount {
     pub is_mayhem_mode: bool,
     /// Whether this coin has cashback enabled (creator fee redirected to users)
     pub is_cashback_coin: bool,
+    /// Quote mint for V2 curves. Defaults to WSOL for legacy/event payloads that do not expose it.
+    pub quote_mint: Pubkey,
 }
 
 impl BondingCurveAccount {
+    #[inline]
+    pub fn normalize_quote_mint(quote_mint: Pubkey) -> Pubkey {
+        if quote_mint == Pubkey::default() || quote_mint == crate::constants::SOL_TOKEN_ACCOUNT {
+            crate::constants::WSOL_TOKEN_ACCOUNT
+        } else {
+            quote_mint
+        }
+    }
+
+    #[inline]
+    pub fn effective_quote_mint(&self) -> Pubkey {
+        Self::normalize_quote_mint(self.quote_mint)
+    }
+
+    #[inline]
+    pub fn initial_virtual_quote_reserves_for_quote_mint(quote_mint: &Pubkey) -> u64 {
+        if *quote_mint == crate::constants::USDC_TOKEN_ACCOUNT {
+            INITIAL_VIRTUAL_USDC_RESERVES
+        } else {
+            INITIAL_VIRTUAL_SOL_RESERVES
+        }
+    }
+
+    #[inline]
+    pub fn virtual_quote_reserves(&self) -> u64 {
+        self.virtual_sol_reserves
+    }
+
+    #[inline]
+    pub fn real_quote_reserves(&self) -> u64 {
+        self.real_sol_reserves
+    }
+
+    #[inline]
+    pub fn with_quote_mint(mut self, quote_mint: Pubkey) -> Self {
+        let quote_mint = Self::normalize_quote_mint(quote_mint);
+        let old_initial =
+            Self::initial_virtual_quote_reserves_for_quote_mint(&self.effective_quote_mint());
+        let new_initial = Self::initial_virtual_quote_reserves_for_quote_mint(&quote_mint);
+        if self.virtual_sol_reserves == old_initial.saturating_add(self.real_sol_reserves) {
+            self.virtual_sol_reserves = new_initial.saturating_add(self.real_sol_reserves);
+        }
+        self.quote_mint = quote_mint;
+        self
+    }
+
     /// When building from event/parser data (e.g. sol-parser-sdk), pass the token's cashback flag
     /// so that sell instructions include the correct remaining accounts. From RPC use `from_mint_by_rpc` instead.
     pub fn from_dev_trade(
@@ -75,24 +123,50 @@ impl BondingCurveAccount {
         creator: Pubkey,
         is_mayhem_mode: bool,
         is_cashback_coin: bool,
+    ) -> Self {
+        Self::from_dev_trade_with_quote_mint(
+            bonding_curve,
+            mint,
+            dev_token_amount,
+            dev_sol_amount,
+            creator,
+            is_mayhem_mode,
+            is_cashback_coin,
+            crate::constants::WSOL_TOKEN_ACCOUNT,
+        )
+    }
+
+    /// Same as [`Self::from_dev_trade`], but quote-aware for V2 pools such as USDC.
+    pub fn from_dev_trade_with_quote_mint(
+        bonding_curve: Pubkey,
+        mint: &Pubkey,
+        dev_token_amount: u64,
+        dev_quote_amount: u64,
+        creator: Pubkey,
+        is_mayhem_mode: bool,
+        is_cashback_coin: bool,
+        quote_mint: Pubkey,
     ) -> Self {
         let account = if bonding_curve != Pubkey::default() {
             bonding_curve
         } else {
             get_bonding_curve_pda(&mint).unwrap()
         };
+        let quote_mint = Self::normalize_quote_mint(quote_mint);
         Self {
             discriminator: 0,
             account: account,
             virtual_token_reserves: INITIAL_VIRTUAL_TOKEN_RESERVES - dev_token_amount,
-            virtual_sol_reserves: INITIAL_VIRTUAL_SOL_RESERVES + dev_sol_amount,
+            virtual_sol_reserves: Self::initial_virtual_quote_reserves_for_quote_mint(&quote_mint)
+                + dev_quote_amount,
             real_token_reserves: INITIAL_REAL_TOKEN_RESERVES - dev_token_amount,
-            real_sol_reserves: dev_sol_amount,
+            real_sol_reserves: dev_quote_amount,
             token_total_supply: TOKEN_TOTAL_SUPPLY,
             complete: false,
             creator: creator,
             is_mayhem_mode: is_mayhem_mode,
             is_cashback_coin,
+            quote_mint,
         }
     }
 
@@ -108,24 +182,53 @@ impl BondingCurveAccount {
         real_sol_reserves: u64,
         is_mayhem_mode: bool,
         is_cashback_coin: bool,
+    ) -> Self {
+        Self::from_trade_with_quote_mint(
+            bonding_curve,
+            mint,
+            creator,
+            virtual_token_reserves,
+            virtual_sol_reserves,
+            real_token_reserves,
+            real_sol_reserves,
+            is_mayhem_mode,
+            is_cashback_coin,
+            crate::constants::WSOL_TOKEN_ACCOUNT,
+        )
+    }
+
+    /// Same as [`Self::from_trade`], but carries the V2 quote mint alongside quote reserves.
+    pub fn from_trade_with_quote_mint(
+        bonding_curve: Pubkey,
+        mint: Pubkey,
+        creator: Pubkey,
+        virtual_token_reserves: u64,
+        virtual_quote_reserves: u64,
+        real_token_reserves: u64,
+        real_quote_reserves: u64,
+        is_mayhem_mode: bool,
+        is_cashback_coin: bool,
+        quote_mint: Pubkey,
     ) -> Self {
         let account = if bonding_curve != Pubkey::default() {
             bonding_curve
         } else {
             get_bonding_curve_pda(&mint).unwrap()
         };
+        let quote_mint = Self::normalize_quote_mint(quote_mint);
         Self {
             discriminator: 0,
             account: account,
             virtual_token_reserves: virtual_token_reserves,
-            virtual_sol_reserves: virtual_sol_reserves,
+            virtual_sol_reserves: virtual_quote_reserves,
             real_token_reserves: real_token_reserves,
-            real_sol_reserves: real_sol_reserves,
+            real_sol_reserves: real_quote_reserves,
             token_total_supply: TOKEN_TOTAL_SUPPLY,
             complete: false,
             creator: creator,
             is_mayhem_mode: is_mayhem_mode,
             is_cashback_coin,
+            quote_mint,
         }
     }
 

src/common/fast_fn.rs

@@ -4,7 +4,7 @@ use solana_sdk::{
     instruction::{AccountMeta, Instruction},
     pubkey::Pubkey,
 };
-use std::sync::Arc;
+use std::{hash::Hash, sync::Arc};
 
 use crate::common::{
     spl_associated_token_account::get_associated_token_address_with_program_id,
@@ -21,6 +21,22 @@ const MAX_PDA_CACHE_SIZE: usize = 100_000;
 const MAX_ATA_CACHE_SIZE: usize = 100_000;
 const MAX_INSTRUCTION_CACHE_SIZE: usize = 100_000;
 
+#[inline]
+fn prune_cache<K, V>(cache: &DashMap<K, V>, max_size: usize)
+where
+    K: Eq + Hash + Clone,
+{
+    let len = cache.len();
+    if len <= max_size {
+        return;
+    }
+    let remove_count = (len - max_size).max(max_size / 16).min(len);
+    let keys: Vec<K> = cache.iter().take(remove_count).map(|entry| entry.key().clone()).collect();
+    for key in keys {
+        cache.remove(&key);
+    }
+}
+
 // --------------------- Instruction Cache ---------------------
 
 /// Instruction cache key for uniquely identifying instruction types and parameters
@@ -66,7 +82,10 @@ where
     };
 
     // Lock-free cache lookup with entry API
-    INSTRUCTION_CACHE.entry(cache_key).or_insert_with(|| Arc::new(compute_fn())).clone()
+    let instructions =
+        INSTRUCTION_CACHE.entry(cache_key).or_insert_with(|| Arc::new(compute_fn())).clone();
+    prune_cache(&INSTRUCTION_CACHE, MAX_INSTRUCTION_CACHE_SIZE);
+    instructions
 }
 
 // --------------------- Associated Token Account ---------------------
@@ -106,8 +125,26 @@ pub fn _create_associated_token_account_idempotent_fast(
         use_seed,
     };
 
-    // Only use seed if the mint address is not wSOL or SOL
-    // 🔧 修复：Token-2022 也支持 seed 方式（白名单方式更安全）
+    let build_standard_create = || {
+        let associated_token_address =
+            get_associated_token_address_with_program_id_fast(owner, mint, token_program);
+        vec![Instruction {
+            program_id: crate::constants::ASSOCIATED_TOKEN_PROGRAM_ID,
+            accounts: vec![
+                AccountMeta::new(*payer, true), // Payer (signer, writable)
+                AccountMeta::new(associated_token_address, false), // ATA address (writable, non-signer)
+                AccountMeta::new_readonly(*owner, false), // Token account owner (readonly, non-signer)
+                AccountMeta::new_readonly(*mint, false), // Token mint address (readonly, non-signer)
+                crate::constants::SYSTEM_PROGRAM_META,
+                AccountMeta::new_readonly(*token_program, false), // Token program (readonly, non-signer)
+            ],
+            data: vec![1],
+        }]
+    };
+
+    // Only use seed if the mint address is not wSOL or SOL.
+    // Seed accounts are deterministic token accounts, not ATAs; callers must ensure they are not
+    // recreating an existing seeded account. Fall back to idempotent ATA if seed assembly fails.
     let arc_instructions = if use_seed
         && !mint.eq(&crate::constants::WSOL_TOKEN_ACCOUNT)
         && !mint.eq(&crate::constants::SOL_TOKEN_ACCOUNT)
@@ -117,29 +154,18 @@ pub fn _create_associated_token_account_idempotent_fast(
         // Use cache to get instruction
         get_cached_instructions(cache_key, || {
             super::seed::create_associated_token_account_use_seed(payer, owner, mint, token_program)
-                .unwrap()
+                .unwrap_or_else(|err| {
+                    tracing::warn!(
+                        "seed token account setup failed for mint {}: {}; fallback to idempotent ATA",
+                        mint,
+                        err
+                    );
+                    build_standard_create()
+                })
         })
     } else {
         // Use cache to get instruction
-        get_cached_instructions(cache_key, || {
-            // Get Associated Token Address using cache
-            let associated_token_address =
-                get_associated_token_address_with_program_id_fast(owner, mint, token_program);
-            // Create Associated Token Account instruction
-            // Reference implementation of spl_associated_token_account::instruction::create_associated_token_account
-            vec![Instruction {
-                program_id: crate::constants::ASSOCIATED_TOKEN_PROGRAM_ID,
-                accounts: vec![
-                    AccountMeta::new(*payer, true), // Payer (signer, writable)
-                    AccountMeta::new(associated_token_address, false), // ATA address (writable, non-signer)
-                    AccountMeta::new_readonly(*owner, false), // Token account owner (readonly, non-signer)
-                    AccountMeta::new_readonly(*mint, false), // Token mint address (readonly, non-signer)
-                    crate::constants::SYSTEM_PROGRAM_META,
-                    AccountMeta::new_readonly(*token_program, false), // Token program (readonly, non-signer)
-                ],
-                data: vec![1],
-            }]
-        })
+        get_cached_instructions(cache_key, build_standard_create)
     };
 
     // 🚀 性能优化：尝试零开销解包 Arc，如果引用计数=1则直接移出，否则克隆
@@ -183,6 +209,7 @@ where
 
     if let Some(pda) = pda_result {
         PDA_CACHE.insert(cache_key, pda);
+        prune_cache(&PDA_CACHE, MAX_PDA_CACHE_SIZE);
     }
 
     pda_result
@@ -265,7 +292,18 @@ fn _get_associated_token_address_with_program_id_fast(
             token_mint_address,
             token_program_id,
         )
-        .unwrap()
+        .unwrap_or_else(|err| {
+            tracing::warn!(
+                "seed token account address failed for mint {}: {}; fallback to ATA",
+                token_mint_address,
+                err
+            );
+            get_associated_token_address_with_program_id(
+                wallet_address,
+                token_mint_address,
+                token_program_id,
+            )
+        })
     } else {
         get_associated_token_address_with_program_id(
             wallet_address,
@@ -276,6 +314,7 @@ fn _get_associated_token_address_with_program_id_fast(
 
     // Store computation result in cache (lock-free)
     ATA_CACHE.insert(cache_key, ata);
+    prune_cache(&ATA_CACHE, MAX_ATA_CACHE_SIZE);
 
     ata
 }

src/common/gas_fee_strategy.rs

@@ -1,6 +1,6 @@
 use crate::swqos::{SwqosType, TradeType};
 use arc_swap::ArcSwap;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::sync::Arc;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -14,6 +14,15 @@ impl GasFeeStrategyType {
     pub fn values() -> Vec<Self> {
         vec![Self::Normal, Self::LowTipHighCuPrice, Self::HighTipLowCuPrice]
     }
+
+    #[inline]
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            Self::Normal => "Normal",
+            Self::LowTipHighCuPrice => "LowTipHighCuPrice",
+            Self::HighTipLowCuPrice => "HighTipLowCuPrice",
+        }
+    }
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -84,6 +93,33 @@ impl GasFeeStrategy {
         );
     }
 
+    /// 设置 Default/RPC 的优先费-only 策略。Default 没有 relay tip account，
+    /// 但仍应携带 ComputeBudget 优先费。
+    pub fn set_default_rpc_fee_strategy(
+        &self,
+        buy_cu_limit: u32,
+        sell_cu_limit: u32,
+        buy_cu_price: u64,
+        sell_cu_price: u64,
+    ) {
+        self.set(
+            SwqosType::Default,
+            TradeType::Buy,
+            GasFeeStrategyType::Normal,
+            buy_cu_limit,
+            buy_cu_price,
+            0.0,
+        );
+        self.set(
+            SwqosType::Default,
+            TradeType::Sell,
+            GasFeeStrategyType::Normal,
+            sell_cu_limit,
+            sell_cu_price,
+            0.0,
+        );
+    }
+
     /// 为多个服务类型添加高低费率策略，会移除(SwqosType,TradeType)的默认策略。
     /// Add high-low fee strategies for multiple service types, Will remove the default strategy of (SwqosType,TradeType)
     pub fn set_high_low_fee_strategies(
@@ -271,7 +307,7 @@ impl GasFeeStrategy {
     ) -> Vec<(SwqosType, GasFeeStrategyType, GasFeeStrategyValue)> {
         let strategies = self.strategies.load();
         let mut result = Vec::new();
-        let mut swqos_types = std::collections::HashSet::new();
+        let mut swqos_types = HashSet::new();
         for (swqos_type, t_type, _) in strategies.keys() {
             if *t_type == trade_type {
                 swqos_types.insert(*swqos_type);
@@ -298,10 +334,17 @@ impl GasFeeStrategy {
     /// 动态更新买入小费（保持其他参数不变）
     /// Dynamically update buy tip (keep other parameters unchanged)
     pub fn update_buy_tip(&self, buy_tip: f64) {
+        self.update_buy_tip_for_strategy(GasFeeStrategyType::Normal, buy_tip);
+    }
+
+    /// 动态更新指定买入策略的小费（保持其他参数不变）。
+    /// Dynamic updates should generally target Normal only; updating all strategies would
+    /// collapse the low-tip/high-tip dual-lane spread into the same tip.
+    pub fn update_buy_tip_for_strategy(&self, strategy_type: GasFeeStrategyType, buy_tip: f64) {
         self.strategies.rcu(|current_map| {
             let mut new_map = (**current_map).clone();
-            for ((_swqos_type, trade_type, _strategy_type), value) in new_map.iter_mut() {
-                if *trade_type == TradeType::Buy {
+            for ((_swqos_type, trade_type, s_type), value) in new_map.iter_mut() {
+                if *trade_type == TradeType::Buy && *s_type == strategy_type {
                     value.tip = buy_tip;
                 }
             }
@@ -312,10 +355,15 @@ impl GasFeeStrategy {
     /// 动态更新卖出小费（保持其他参数不变）
     /// Dynamically update sell tip (keep other parameters unchanged)
     pub fn update_sell_tip(&self, sell_tip: f64) {
+        self.update_sell_tip_for_strategy(GasFeeStrategyType::Normal, sell_tip);
+    }
+
+    /// 动态更新指定卖出策略的小费（保持其他参数不变）。
+    pub fn update_sell_tip_for_strategy(&self, strategy_type: GasFeeStrategyType, sell_tip: f64) {
         self.strategies.rcu(|current_map| {
             let mut new_map = (**current_map).clone();
-            for ((_swqos_type, trade_type, _strategy_type), value) in new_map.iter_mut() {
-                if *trade_type == TradeType::Sell {
+            for ((_swqos_type, trade_type, s_type), value) in new_map.iter_mut() {
+                if *trade_type == TradeType::Sell && *s_type == strategy_type {
                     value.tip = sell_tip;
                 }
             }
@@ -326,10 +374,19 @@ impl GasFeeStrategy {
     /// 动态更新买入优先费（保持其他参数不变）
     /// Dynamically update buy compute unit price (keep other parameters unchanged)
     pub fn update_buy_cu_price(&self, buy_cu_price: u64) {
+        self.update_buy_cu_price_for_strategy(GasFeeStrategyType::Normal, buy_cu_price);
+    }
+
+    /// 动态更新指定买入策略的优先费（保持其他参数不变）。
+    pub fn update_buy_cu_price_for_strategy(
+        &self,
+        strategy_type: GasFeeStrategyType,
+        buy_cu_price: u64,
+    ) {
         self.strategies.rcu(|current_map| {
             let mut new_map = (**current_map).clone();
-            for ((_swqos_type, trade_type, _strategy_type), value) in new_map.iter_mut() {
-                if *trade_type == TradeType::Buy {
+            for ((_swqos_type, trade_type, s_type), value) in new_map.iter_mut() {
+                if *trade_type == TradeType::Buy && *s_type == strategy_type {
                     value.cu_price = buy_cu_price;
                 }
             }
@@ -340,10 +397,19 @@ impl GasFeeStrategy {
     /// 动态更新卖出优先费（保持其他参数不变）
     /// Dynamically update sell compute unit price (keep other parameters unchanged)
     pub fn update_sell_cu_price(&self, sell_cu_price: u64) {
+        self.update_sell_cu_price_for_strategy(GasFeeStrategyType::Normal, sell_cu_price);
+    }
+
+    /// 动态更新指定卖出策略的优先费（保持其他参数不变）。
+    pub fn update_sell_cu_price_for_strategy(
+        &self,
+        strategy_type: GasFeeStrategyType,
+        sell_cu_price: u64,
+    ) {
         self.strategies.rcu(|current_map| {
             let mut new_map = (**current_map).clone();
-            for ((_swqos_type, trade_type, _strategy_type), value) in new_map.iter_mut() {
-                if *trade_type == TradeType::Sell {
+            for ((_swqos_type, trade_type, s_type), value) in new_map.iter_mut() {
+                if *trade_type == TradeType::Sell && *s_type == strategy_type {
                     value.cu_price = sell_cu_price;
                 }
             }
@@ -365,3 +431,106 @@ impl GasFeeStrategy {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn find_strategy(
+        strategies: &[(SwqosType, GasFeeStrategyType, GasFeeStrategyValue)],
+        swqos_type: SwqosType,
+        strategy_type: GasFeeStrategyType,
+    ) -> GasFeeStrategyValue {
+        strategies
+            .iter()
+            .find(|(s, t, _)| *s == swqos_type && *t == strategy_type)
+            .map(|(_, _, v)| *v)
+            .expect("strategy exists")
+    }
+
+    #[test]
+    fn high_low_fee_strategy_expands_two_lanes_per_swqos() {
+        let strategy = GasFeeStrategy::new();
+
+        strategy.set_high_low_fee_strategies(
+            &[SwqosType::Jito, SwqosType::Helius],
+            TradeType::Buy,
+            100_000,
+            180_000,
+            400_000,
+            0.002,
+            0.005,
+        );
+
+        let strategies = strategy.get_strategies(TradeType::Buy);
+        assert_eq!(strategies.len(), 4);
+
+        for swqos_type in [SwqosType::Jito, SwqosType::Helius] {
+            let low_tip_high_cu =
+                find_strategy(&strategies, swqos_type, GasFeeStrategyType::LowTipHighCuPrice);
+            assert_eq!(low_tip_high_cu.cu_limit, 100_000);
+            assert_eq!(low_tip_high_cu.cu_price, 400_000);
+            assert_eq!(low_tip_high_cu.tip, 0.002);
+
+            let high_tip_low_cu =
+                find_strategy(&strategies, swqos_type, GasFeeStrategyType::HighTipLowCuPrice);
+            assert_eq!(high_tip_low_cu.cu_limit, 100_000);
+            assert_eq!(high_tip_low_cu.cu_price, 180_000);
+            assert_eq!(high_tip_low_cu.tip, 0.005);
+        }
+    }
+
+    #[test]
+    fn dynamic_updates_do_not_collapse_dual_lane_fees() {
+        let strategy = GasFeeStrategy::new();
+
+        strategy.set_high_low_fee_strategy(
+            SwqosType::Jito,
+            TradeType::Buy,
+            100_000,
+            180_000,
+            400_000,
+            0.002,
+            0.005,
+        );
+
+        strategy.update_buy_tip(0.009);
+        strategy.update_buy_cu_price(999_999);
+
+        let strategies = strategy.get_strategies(TradeType::Buy);
+        let low_tip_high_cu =
+            find_strategy(&strategies, SwqosType::Jito, GasFeeStrategyType::LowTipHighCuPrice);
+        let high_tip_low_cu =
+            find_strategy(&strategies, SwqosType::Jito, GasFeeStrategyType::HighTipLowCuPrice);
+
+        assert_eq!(low_tip_high_cu.cu_price, 400_000);
+        assert_eq!(low_tip_high_cu.tip, 0.002);
+        assert_eq!(high_tip_low_cu.cu_price, 180_000);
+        assert_eq!(high_tip_low_cu.tip, 0.005);
+    }
+
+    #[test]
+    fn default_rpc_strategy_uses_priority_fee_without_tip() {
+        let strategy = GasFeeStrategy::new();
+
+        strategy.set_default_rpc_fee_strategy(100_000, 90_000, 700_000, 800_000);
+
+        let buy = find_strategy(
+            &strategy.get_strategies(TradeType::Buy),
+            SwqosType::Default,
+            GasFeeStrategyType::Normal,
+        );
+        assert_eq!(buy.cu_limit, 100_000);
+        assert_eq!(buy.cu_price, 700_000);
+        assert_eq!(buy.tip, 0.0);
+
+        let sell = find_strategy(
+            &strategy.get_strategies(TradeType::Sell),
+            SwqosType::Default,
+            GasFeeStrategyType::Normal,
+        );
+        assert_eq!(sell.cu_limit, 90_000);
+        assert_eq!(sell.cu_price, 800_000);
+        assert_eq!(sell.tip, 0.0);
+    }
+}

src/common/sdk_log.rs

@@ -84,7 +84,7 @@ pub fn print_sdk_timing_block(
     start_us: Option<i64>,
     build_end_us: Option<i64>,
     before_submit_us: Option<i64>,
-    submit_timings: &[(crate::swqos::SwqosType, i64)],
+    submit_timings: &[crate::common::SwqosSubmitTiming],
     confirm_us: Option<i64>,
 ) {
     println!();
@@ -112,13 +112,14 @@ pub fn print_sdk_timing_block(
     }
     if let Some(confirm_done_us) = confirm_us {
         let total_ms = (confirm_done_us - start_us) as f64 / 1000.0;
-        for (swqos_type, submit_done_us) in submit_timings {
-            let submit_ms = (*submit_done_us - start_us).max(0) as f64 / 1000.0;
-            let confirmed_ms = (confirm_done_us - *submit_done_us).max(0) as f64 / 1000.0;
+        for timing in submit_timings {
+            let submit_ms = (timing.submit_done_us - start_us).max(0) as f64 / 1000.0;
+            let confirmed_ms = (confirm_done_us - timing.submit_done_us).max(0) as f64 / 1000.0;
             println!(
-                " [SDK][{:width$}] {} submit_done: {:.4} ms, confirmed: {:.4} ms, total: {:.4} ms",
-                swqos_type.as_str(),
+                " [SDK][{:width$}] {} {} submit_done: {:.4} ms, confirmed: {:.4} ms, total: {:.4} ms",
+                timing.swqos_type.as_str(),
                 dir,
+                timing.strategy_type.as_str(),
                 submit_ms,
                 confirmed_ms,
                 total_ms,
@@ -126,12 +127,13 @@ pub fn print_sdk_timing_block(
             );
         }
     } else {
-        for (swqos_type, submit_done_us) in submit_timings {
-            let submit_ms = (*submit_done_us - start_us).max(0) as f64 / 1000.0;
+        for timing in submit_timings {
+            let submit_ms = (timing.submit_done_us - start_us).max(0) as f64 / 1000.0;
             println!(
-                " [SDK][{:width$}] {} submit_done: {:.4} ms, confirmed: -, total: {:.4} ms",
-                swqos_type.as_str(),
+                " [SDK][{:width$}] {} {} submit_done: {:.4} ms, confirmed: -, total: {:.4} ms",
+                timing.swqos_type.as_str(),
                 dir,
+                timing.strategy_type.as_str(),
                 submit_ms,
                 submit_ms,
                 width = SWQOS_LABEL_WIDTH

src/common/seed.rs

@@ -1,5 +1,4 @@
 use crate::common::SolanaRpcClient;
-use anyhow::anyhow;
 use fnv::FnvHasher;
 use once_cell::sync::Lazy;
 use solana_sdk::{instruction::Instruction, pubkey::Pubkey};
@@ -50,6 +49,26 @@ async fn fetch_rent_for_token_account(
     Ok(client.get_minimum_balance_for_rent_exemption(165).await?)
 }
 
+#[inline]
+fn derive_seed_from_mint(mint: &Pubkey) -> String {
+    // Keep the legacy 8-hex seed stable. Changing this derivation changes the token account
+    // address and can strand balances created by earlier buys.
+    let mut hasher = FnvHasher::default();
+    hasher.write(mint.as_ref());
+    let hash = hasher.finish();
+    let v = (hash & 0xFFFF_FFFF) as u32;
+    let mut seed = String::with_capacity(8);
+    for i in 0..8 {
+        let nibble = ((v >> (28 - i * 4)) & 0xF) as u8;
+        let byte = match nibble {
+            0..=9 => b'0' + nibble,
+            _ => b'a' + (nibble - 10),
+        };
+        seed.push(byte as char);
+    }
+    seed
+}
+
 pub fn create_associated_token_account_use_seed(
     payer: &Pubkey,
     owner: &Pubkey,
@@ -63,33 +82,23 @@ pub fn create_associated_token_account_use_seed(
     let rent = if is_2022_token {
         let v = SPL_TOKEN_2022_RENT.load(Ordering::Relaxed);
         if v == u64::MAX {
-            return Err(anyhow!("Rent not initialized"));
+            DEFAULT_TOKEN_ACCOUNT_RENT
+        } else {
+            v
         }
-        v
     } else {
         let v = SPL_TOKEN_RENT.load(Ordering::Relaxed);
         if v == u64::MAX {
-            return Err(anyhow!("Rent not initialized"));
+            DEFAULT_TOKEN_ACCOUNT_RENT
+        } else {
+            v
         }
-        v
     };
 
-    let mut buf = [0u8; 8];
-    let mut hasher = FnvHasher::default();
-    hasher.write(mint.as_ref());
-    let hash = hasher.finish();
-    let v = (hash & 0xFFFF_FFFF) as u32;
-    for i in 0..8 {
-        let nibble = ((v >> (28 - i * 4)) & 0xF) as u8;
-        buf[i] = match nibble {
-            0..=9 => b'0' + nibble,
-            _ => b'a' + (nibble - 10),
-        };
-    }
-    let seed = unsafe { std::str::from_utf8_unchecked(&buf) };
+    let seed = derive_seed_from_mint(mint);
     // 🔧 修复：使用传入的 token_program 生成地址（支持 Token 和 Token-2022）
     // 买入和卖出只要都使用事件中的 token_program，地址自然一致
-    let ata_like = Pubkey::create_with_seed(payer, seed, token_program)?;
+    let ata_like = Pubkey::create_with_seed(payer, &seed, token_program)?;
 
     let len = 165;
     // 🔧 修复：create_account_with_seed 的第3个参数必须是 payer（与第92行生成地址时使用的 base 一致）
@@ -98,7 +107,7 @@ pub fn create_associated_token_account_use_seed(
         payer,
         &ata_like,
         payer,
-        seed,
+        &seed,
         rent,
         len,
         token_program,
@@ -118,21 +127,9 @@ pub fn get_associated_token_address_with_program_id_use_seed(
     token_mint_address: &Pubkey,
     token_program_id: &Pubkey,
 ) -> Result<Pubkey, anyhow::Error> {
-    let mut buf = [0u8; 8];
-    let mut hasher = FnvHasher::default();
-    hasher.write(token_mint_address.as_ref());
-    let hash = hasher.finish();
-    let v = (hash & 0xFFFF_FFFF) as u32;
-    for i in 0..8 {
-        let nibble = ((v >> (28 - i * 4)) & 0xF) as u8;
-        buf[i] = match nibble {
-            0..=9 => b'0' + nibble,
-            _ => b'a' + (nibble - 10),
-        };
-    }
-    let seed = unsafe { std::str::from_utf8_unchecked(&buf) };
+    let seed = derive_seed_from_mint(token_mint_address);
     // 🔧 修复：使用传入的 token_program_id 生成地址（支持 Token 和 Token-2022）
     // 买入和卖出只要都使用事件中的 token_program_id，地址自然一致
-    let ata_like = Pubkey::create_with_seed(wallet_address, seed, token_program_id)?;
+    let ata_like = Pubkey::create_with_seed(wallet_address, &seed, token_program_id)?;
     Ok(ata_like)
 }

src/common/types.rs

@@ -1,4 +1,5 @@
-use crate::swqos::SwqosConfig;
+use crate::common::GasFeeStrategyType;
+use crate::swqos::{SwqosConfig, SwqosType};
 use solana_commitment_config::CommitmentConfig;
 use std::hash::{Hash, Hasher};
 
@@ -75,6 +76,13 @@ impl PartialEq for InfrastructureConfig {
 
 impl Eq for InfrastructureConfig {}
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct SwqosSubmitTiming {
+    pub swqos_type: SwqosType,
+    pub strategy_type: GasFeeStrategyType,
+    pub submit_done_us: i64,
+}
+
 #[derive(Debug, Clone)]
 pub struct TradeConfig {
     pub rpc_url: String,
@@ -95,9 +103,6 @@ pub struct TradeConfig {
     /// (Astralane QUIC `:9000` or Plain/Binary HTTP `mev-protect=true`, BlockRazor sandwichMitigation)
     /// use their MEV-protected endpoints/modes. Default false (no MEV protection, lower latency).
     pub mev_protection: bool,
-    /// Use PumpFun V2 instructions (buy_v2 / sell_v2, 27/26-account metas, quote_mint support).
-    /// Default: `false` keeps legacy SOL-paired instructions for smaller transactions; V2 is the official future-proof interface.
-    pub use_pumpfun_v2: bool,
 }
 
 impl TradeConfig {
@@ -152,7 +157,6 @@ pub struct TradeConfigBuilder {
     check_min_tip: bool,
     swqos_cores_from_end: bool,
     mev_protection: bool,
-    use_pumpfun_v2: bool,
 }
 
 impl TradeConfigBuilder {
@@ -167,7 +171,6 @@ impl TradeConfigBuilder {
             check_min_tip: false,
             swqos_cores_from_end: false,
             mev_protection: false,
-            use_pumpfun_v2: false,
         }
     }
 
@@ -213,14 +216,6 @@ impl TradeConfigBuilder {
         self
     }
 
-    /// Use PumpFun V2 instructions (`buy_v2` / `sell_v2`, 27-account metas, `quote_mint` support).
-    /// Default: `false` (V1 — 18-account metas, legacy SOL-paired, smaller transaction).
-    /// Set to `true` when PumpFun officially deploys V2 on mainnet.
-    pub fn use_pumpfun_v2(mut self, v: bool) -> Self {
-        self.use_pumpfun_v2 = v;
-        self
-    }
-
     /// Consume the builder and produce a [`TradeConfig`].
     pub fn build(self) -> TradeConfig {
         TradeConfig {
@@ -233,7 +228,6 @@ impl TradeConfigBuilder {
             check_min_tip: self.check_min_tip,
             swqos_cores_from_end: self.swqos_cores_from_end,
             mev_protection: self.mev_protection,
-            use_pumpfun_v2: self.use_pumpfun_v2,
         }
     }
 }

src/instruction/bonk.rs

@@ -389,7 +389,6 @@ mod tests {
             check_min_tip: false,
             grpc_recv_us: None,
             use_exact_sol_amount: None,
-            use_pumpfun_v2: false,
         }
     }
 

src/instruction/meteora_damm_v2.rs

@@ -371,7 +371,6 @@ mod tests {
             check_min_tip: false,
             grpc_recv_us: None,
             use_exact_sol_amount: None,
-            use_pumpfun_v2: false,
         }
     }
 

src/instruction/pumpfun.rs

@@ -1,10 +1,12 @@
 //! Pump.fun bonding-curve swap ix assembly ([`SwapParams`](crate::trading::core::params::SwapParams)).
 //!
-//! Runtime flag: set `SwapParams.use_pumpfun_v2 = true` to use `buy_v2` / `sell_v2` /
-//! `buy_exact_quote_in_v2` (27/26-account unified metas, quote_mint support).
+//! The SDK selects the legacy or V2 on-chain layout from `PumpFunParams.quote_mint`.
+//! `Pubkey::default()` and the Solscan SOL sentinel keep the smaller legacy SOL layout;
+//! explicit WSOL or USDC uses the V2 27/26-account unified metas.
 //! Default (`false`) keeps the smaller legacy SOL-paired instruction layout for latency.
 
 use crate::{
+    common::bonding_curve::BondingCurveAccount,
     common::spl_token::close_account,
     constants::{trade::trade::DEFAULT_SLIPPAGE, TOKEN_PROGRAM_2022},
     trading::core::{
@@ -30,11 +32,14 @@ use crate::{
     },
 };
 use anyhow::{anyhow, Result};
-use solana_sdk::instruction::AccountMeta;
-use solana_sdk::{instruction::Instruction, pubkey::Pubkey, signer::Signer};
+use solana_sdk::{
+    instruction::{AccountMeta, Instruction},
+    pubkey::Pubkey,
+    signer::Signer,
+};
 
 #[inline]
-fn effective_pump_mint_token_program(_mint: &Pubkey, protocol_params: &PumpFunParams) -> Pubkey {
+fn effective_pump_mint_token_program(protocol_params: &PumpFunParams) -> Pubkey {
     let tp = protocol_params.token_program;
     if tp == Pubkey::default() {
         TOKEN_PROGRAM_2022
@@ -44,35 +49,104 @@ fn effective_pump_mint_token_program(_mint: &Pubkey, protocol_params: &PumpFunPa
 }
 
 /// Resolve quote mint and its token program from PumpFunParams.
-/// `Pubkey::default()` means legacy SOL-paired → use WSOL mint for V2 instructions.
+/// `Pubkey::default()` / `SOL_TOKEN_ACCOUNT` means legacy SOL-paired; use WSOL mint when a
+/// downstream V2 helper needs a concrete SPL quote mint.
 #[inline]
 fn effective_quote_mint_and_token_program(protocol_params: &PumpFunParams) -> (Pubkey, Pubkey) {
-    let quote_mint = if protocol_params.quote_mint == Pubkey::default() {
-        crate::constants::WSOL_TOKEN_ACCOUNT
+    let curve_quote_mint = protocol_params.bonding_curve.effective_quote_mint();
+    let quote_mint = if protocol_params.quote_mint != Pubkey::default() {
+        BondingCurveAccount::normalize_quote_mint(protocol_params.quote_mint)
+    } else if curve_quote_mint != Pubkey::default() {
+        curve_quote_mint
     } else {
-        protocol_params.quote_mint
+        crate::constants::WSOL_TOKEN_ACCOUNT
     };
     (quote_mint, crate::constants::TOKEN_PROGRAM)
 }
 
+#[inline]
+fn is_sol_quote_mint(quote_mint: &Pubkey) -> bool {
+    *quote_mint == crate::constants::WSOL_TOKEN_ACCOUNT
+        || *quote_mint == crate::constants::SOL_TOKEN_ACCOUNT
+}
+
+#[inline]
+fn validate_v2_buy_quote_mint(input_mint: &Pubkey, quote_mint: &Pubkey) -> Result<()> {
+    if is_sol_quote_mint(quote_mint) {
+        if *input_mint == crate::constants::SOL_TOKEN_ACCOUNT
+            || *input_mint == crate::constants::WSOL_TOKEN_ACCOUNT
+        {
+            return Ok(());
+        }
+    } else if input_mint == quote_mint {
+        return Ok(());
+    }
+    Err(anyhow!(
+        "PumpFun V2 buy input_mint {} does not match quote_mint {}; USDC quote pools must be bought with USDC, not SOL",
+        input_mint,
+        quote_mint
+    ))
+}
+
+#[inline]
+fn validate_v2_sell_quote_mint(output_mint: &Pubkey, quote_mint: &Pubkey) -> Result<()> {
+    if is_sol_quote_mint(quote_mint) {
+        if *output_mint == crate::constants::SOL_TOKEN_ACCOUNT
+            || *output_mint == crate::constants::WSOL_TOKEN_ACCOUNT
+        {
+            return Ok(());
+        }
+    } else if output_mint == quote_mint {
+        return Ok(());
+    }
+    Err(anyhow!(
+        "PumpFun V2 sell output_mint {} does not match quote_mint {}; USDC quote pools settle to USDC, not SOL",
+        output_mint,
+        quote_mint
+    ))
+}
+
 pub struct PumpFunInstructionBuilder;
 
 #[async_trait::async_trait]
 impl InstructionBuilder for PumpFunInstructionBuilder {
     async fn build_buy_instructions(&self, params: &SwapParams) -> Result<Vec<Instruction>> {
-        if params.use_pumpfun_v2 {
-            build_buy_v2(params)
-        } else {
-            build_buy_v1(params)
-        }
+        build_buy(params)
     }
 
     async fn build_sell_instructions(&self, params: &SwapParams) -> Result<Vec<Instruction>> {
-        if params.use_pumpfun_v2 {
-            build_sell_v2(params)
-        } else {
-            build_sell_v1(params)
-        }
+        build_sell(params)
+    }
+}
+
+#[inline]
+fn should_use_v2_layout(params: &SwapParams) -> Result<bool> {
+    let protocol_params = params
+        .protocol_params
+        .as_any()
+        .downcast_ref::<PumpFunParams>()
+        .ok_or_else(|| anyhow!("Invalid protocol params for PumpFun"))?;
+    let (quote_mint, _) = effective_quote_mint_and_token_program(protocol_params);
+    let explicit_v2_quote = protocol_params.quote_mint != Pubkey::default()
+        && protocol_params.quote_mint != crate::constants::SOL_TOKEN_ACCOUNT;
+    Ok(explicit_v2_quote || !is_sol_quote_mint(&quote_mint))
+}
+
+#[inline]
+fn build_buy(params: &SwapParams) -> Result<Vec<Instruction>> {
+    if should_use_v2_layout(params)? {
+        build_buy_unified(params)
+    } else {
+        build_buy_legacy(params)
+    }
+}
+
+#[inline]
+fn build_sell(params: &SwapParams) -> Result<Vec<Instruction>> {
+    if should_use_v2_layout(params)? {
+        build_sell_unified(params)
+    } else {
+        build_sell_legacy(params)
     }
 }
 
@@ -80,9 +154,9 @@ impl InstructionBuilder for PumpFunInstructionBuilder {
 // V1 (default) — 18 metas, no quote_mint ATA create
 // ---------------------------------------------------------------------------
 
-fn build_buy_v1(params: &SwapParams) -> Result<Vec<Instruction>> {
+fn build_buy_legacy(params: &SwapParams) -> Result<Vec<Instruction>> {
     use crate::instruction::pumpfun_ix_data::{
-        encode_pumpfun_buy_exact_sol_in_ix_data, encode_pumpfun_buy_ix_data,
+        encode_pumpfun_buy_exact_quote_in_ix_data, encode_pumpfun_buy_ix_data, PumpFunIxVersion,
     };
     use crate::instruction::utils::pumpfun::{
         get_bonding_curve_v2_pda, get_protocol_extra_fee_recipient_random,
@@ -116,7 +190,7 @@ fn build_buy_v1(params: &SwapParams) -> Result<Vec<Instruction>> {
     })?;
 
     let is_mayhem_mode = bonding_curve.is_mayhem_mode;
-    let token_program = effective_pump_mint_token_program(&params.output_mint, protocol_params);
+    let token_program = effective_pump_mint_token_program(protocol_params);
     let token_program_meta = if token_program == TOKEN_PROGRAM_2022 {
         crate::constants::TOKEN_PROGRAM_2022_META
     } else {
@@ -157,8 +231,9 @@ fn build_buy_v1(params: &SwapParams) -> Result<Vec<Instruction>> {
 
     // ── Legacy buy path ──
     let track_volume_val = if bonding_curve.is_cashback_coin { 1u8 } else { 0u8 };
+    let ix_version = PumpFunIxVersion::Legacy { track_volume: track_volume_val };
     let buy_data = if let Some(token_amount) = params.fixed_output_amount {
-        encode_pumpfun_buy_ix_data(token_amount, lamports_in, track_volume_val)
+        encode_pumpfun_buy_ix_data(token_amount, lamports_in, ix_version)
     } else {
         let buy_token_amount = get_buy_token_amount_from_sol_amount(
             bonding_curve.virtual_token_reserves as u128,
@@ -169,10 +244,10 @@ fn build_buy_v1(params: &SwapParams) -> Result<Vec<Instruction>> {
         );
         if params.use_exact_sol_amount.unwrap_or(true) {
             let min_tokens_out = calculate_with_slippage_sell(buy_token_amount, slippage_bp);
-            encode_pumpfun_buy_exact_sol_in_ix_data(lamports_in, min_tokens_out, track_volume_val)
+            encode_pumpfun_buy_exact_quote_in_ix_data(lamports_in, min_tokens_out, ix_version)
         } else {
             let max_sol_cost = calculate_with_slippage_buy(lamports_in, slippage_bp);
-            encode_pumpfun_buy_ix_data(buy_token_amount, max_sol_cost, track_volume_val)
+            encode_pumpfun_buy_ix_data(buy_token_amount, max_sol_cost, ix_version)
         }
     };
 
@@ -203,13 +278,13 @@ fn build_buy_v1(params: &SwapParams) -> Result<Vec<Instruction>> {
     metas.push(AccountMeta::new_readonly(bonding_curve_v2, false));
     metas.push(AccountMeta::new(get_protocol_extra_fee_recipient_random(), false));
 
-    instructions.push(Instruction::new_with_bytes(accounts::PUMPFUN, &buy_data, metas));
+    instructions.push(Instruction::new_with_bytes(accounts::PUMPFUN, buy_data.as_slice(), metas));
 
     Ok(instructions)
 }
 
-fn build_sell_v1(params: &SwapParams) -> Result<Vec<Instruction>> {
-    use crate::instruction::pumpfun_ix_data::encode_pumpfun_sell_ix_data;
+fn build_sell_legacy(params: &SwapParams) -> Result<Vec<Instruction>> {
+    use crate::instruction::pumpfun_ix_data::{encode_pumpfun_sell_ix_data, PumpFunIxVersion};
     use crate::instruction::utils::pumpfun::{
         get_bonding_curve_v2_pda, get_protocol_extra_fee_recipient_random,
         is_phantom_default_creator_vault,
@@ -270,7 +345,7 @@ fn build_sell_v1(params: &SwapParams) -> Result<Vec<Instruction>> {
     })?;
 
     let is_mayhem_mode = bonding_curve.is_mayhem_mode;
-    let token_program = effective_pump_mint_token_program(&params.input_mint, protocol_params);
+    let token_program = effective_pump_mint_token_program(protocol_params);
     let token_program_meta = if token_program == TOKEN_PROGRAM_2022 {
         crate::constants::TOKEN_PROGRAM_2022_META
     } else {
@@ -296,7 +371,11 @@ fn build_sell_v1(params: &SwapParams) -> Result<Vec<Instruction>> {
         .ok_or_else(|| anyhow!("user_volume_accumulator PDA derivation failed"))?;
 
     let mut instructions = Vec::with_capacity(2);
-    let sell_data = encode_pumpfun_sell_ix_data(token_amount, min_sol_output);
+    let sell_data = encode_pumpfun_sell_ix_data(
+        token_amount,
+        min_sol_output,
+        PumpFunIxVersion::Legacy { track_volume: 0 },
+    );
 
     let fee_recipient_meta =
         pump_fun_fee_recipient_meta(protocol_params.fee_recipient, is_mayhem_mode);
@@ -328,7 +407,7 @@ fn build_sell_v1(params: &SwapParams) -> Result<Vec<Instruction>> {
     metas.push(AccountMeta::new_readonly(bonding_curve_v2, false));
     metas.push(AccountMeta::new(get_protocol_extra_fee_recipient_random(), false));
 
-    instructions.push(Instruction::new_with_bytes(accounts::PUMPFUN, &sell_data, metas));
+    instructions.push(Instruction::new_with_bytes(accounts::PUMPFUN, sell_data.as_slice(), metas));
 
     if protocol_params.close_token_account_when_sell.unwrap_or(false) || params.close_input_mint_ata
     {
@@ -345,12 +424,12 @@ fn build_sell_v1(params: &SwapParams) -> Result<Vec<Instruction>> {
 }
 
 // ---------------------------------------------------------------------------
-// V2 (opt-in via `use_pumpfun_v2 = true`) — 27 metas, quote_mint ATA create
+// V2 — 27 metas, quote_mint ATA create
 // ---------------------------------------------------------------------------
 
-fn build_buy_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
+fn build_buy_unified(params: &SwapParams) -> Result<Vec<Instruction>> {
     use crate::instruction::pumpfun_ix_data::{
-        encode_pumpfun_buy_exact_quote_in_v2_ix_data, encode_pumpfun_buy_v2_ix_data,
+        encode_pumpfun_buy_exact_quote_in_ix_data, encode_pumpfun_buy_ix_data, PumpFunIxVersion,
     };
     use crate::instruction::utils::pumpfun::{
         get_buyback_fee_recipient_random, get_fee_sharing_config_pda,
@@ -384,8 +463,7 @@ fn build_buy_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
     })?;
 
     let is_mayhem_mode = bonding_curve.is_mayhem_mode;
-    let base_token_program =
-        effective_pump_mint_token_program(&params.output_mint, protocol_params);
+    let base_token_program = effective_pump_mint_token_program(protocol_params);
     let base_token_program_meta = if base_token_program == TOKEN_PROGRAM_2022 {
         crate::constants::TOKEN_PROGRAM_2022_META
     } else {
@@ -393,6 +471,7 @@ fn build_buy_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
     };
 
     let (quote_mint, quote_token_program) = effective_quote_mint_and_token_program(protocol_params);
+    validate_v2_buy_quote_mint(&params.input_mint, &quote_mint)?;
     let quote_token_program_meta = crate::constants::TOKEN_PROGRAM_META;
 
     let associated_base_bonding_curve =
@@ -475,7 +554,7 @@ fn build_buy_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
     }
 
     let (buy_data, quote_amount_to_fund) = if let Some(token_amount) = params.fixed_output_amount {
-        (encode_pumpfun_buy_v2_ix_data(token_amount, lamports_in), lamports_in)
+        (encode_pumpfun_buy_ix_data(token_amount, lamports_in, PumpFunIxVersion::V2), lamports_in)
     } else {
         let buy_token_amount = get_buy_token_amount_from_sol_amount(
             bonding_curve.virtual_token_reserves as u128,
@@ -486,10 +565,20 @@ fn build_buy_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
         );
         if params.use_exact_sol_amount.unwrap_or(true) {
             let min_tokens_out = calculate_with_slippage_sell(buy_token_amount, slippage_bp);
-            (encode_pumpfun_buy_exact_quote_in_v2_ix_data(lamports_in, min_tokens_out), lamports_in)
+            (
+                encode_pumpfun_buy_exact_quote_in_ix_data(
+                    lamports_in,
+                    min_tokens_out,
+                    PumpFunIxVersion::V2,
+                ),
+                lamports_in,
+            )
         } else {
             let max_sol_cost = calculate_with_slippage_buy(lamports_in, slippage_bp);
-            (encode_pumpfun_buy_v2_ix_data(buy_token_amount, max_sol_cost), max_sol_cost)
+            (
+                encode_pumpfun_buy_ix_data(buy_token_amount, max_sol_cost, PumpFunIxVersion::V2),
+                max_sol_cost,
+            )
         }
     };
 
@@ -513,7 +602,7 @@ fn build_buy_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
         AccountMeta::new_readonly(accounts::ASSOCIATED_TOKEN_PROGRAM, false),
         fee_recipient_meta,
         AccountMeta::new(associated_quote_fee_recipient, false),
-        AccountMeta::new_readonly(buyback_fee_recipient, false),
+        AccountMeta::new(buyback_fee_recipient, false),
         AccountMeta::new(associated_quote_buyback_fee_recipient, false),
         AccountMeta::new(bonding_curve_addr, false),
         AccountMeta::new(associated_base_bonding_curve, false),
@@ -534,7 +623,7 @@ fn build_buy_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
         accounts::PUMPFUN_META,
     ];
 
-    instructions.push(Instruction::new_with_bytes(accounts::PUMPFUN, &buy_data, metas));
+    instructions.push(Instruction::new_with_bytes(accounts::PUMPFUN, buy_data.as_slice(), metas));
 
     if params.close_input_mint_ata {
         push_close_wsol_if_needed(&mut instructions, &params.payer.pubkey(), &quote_mint);
@@ -543,8 +632,8 @@ fn build_buy_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
     Ok(instructions)
 }
 
-fn build_sell_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
-    use crate::instruction::pumpfun_ix_data::encode_pumpfun_sell_v2_ix_data;
+fn build_sell_unified(params: &SwapParams) -> Result<Vec<Instruction>> {
+    use crate::instruction::pumpfun_ix_data::{encode_pumpfun_sell_ix_data, PumpFunIxVersion};
     use crate::instruction::utils::pumpfun::{
         get_buyback_fee_recipient_random, get_fee_sharing_config_pda,
         is_phantom_default_creator_vault,
@@ -605,7 +694,7 @@ fn build_sell_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
     })?;
 
     let is_mayhem_mode = bonding_curve.is_mayhem_mode;
-    let base_token_program = effective_pump_mint_token_program(&params.input_mint, protocol_params);
+    let base_token_program = effective_pump_mint_token_program(protocol_params);
     let base_token_program_meta = if base_token_program == TOKEN_PROGRAM_2022 {
         crate::constants::TOKEN_PROGRAM_2022_META
     } else {
@@ -613,6 +702,7 @@ fn build_sell_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
     };
 
     let (quote_mint, quote_token_program) = effective_quote_mint_and_token_program(protocol_params);
+    validate_v2_sell_quote_mint(&params.output_mint, &quote_mint)?;
     let quote_token_program_meta = crate::constants::TOKEN_PROGRAM_META;
 
     let associated_base_bonding_curve =
@@ -692,7 +782,7 @@ fn build_sell_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
         );
     }
 
-    let sell_data = encode_pumpfun_sell_v2_ix_data(token_amount, min_sol_output);
+    let sell_data = encode_pumpfun_sell_ix_data(token_amount, min_sol_output, PumpFunIxVersion::V2);
 
     let metas: Vec<AccountMeta> = vec![
         global_constants::GLOBAL_ACCOUNT_META,
@@ -703,7 +793,7 @@ fn build_sell_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
         AccountMeta::new_readonly(accounts::ASSOCIATED_TOKEN_PROGRAM, false),
         fee_recipient_meta,
         AccountMeta::new(associated_quote_fee_recipient, false),
-        AccountMeta::new_readonly(buyback_fee_recipient, false),
+        AccountMeta::new(buyback_fee_recipient, false),
         AccountMeta::new(associated_quote_buyback_fee_recipient, false),
         AccountMeta::new(bonding_curve_addr, false),
         AccountMeta::new(associated_base_bonding_curve, false),
@@ -723,7 +813,7 @@ fn build_sell_v2(params: &SwapParams) -> Result<Vec<Instruction>> {
         accounts::PUMPFUN_META,
     ];
 
-    instructions.push(Instruction::new_with_bytes(accounts::PUMPFUN, &sell_data, metas));
+    instructions.push(Instruction::new_with_bytes(accounts::PUMPFUN, sell_data.as_slice(), metas));
 
     if protocol_params.close_token_account_when_sell.unwrap_or(false) || params.close_input_mint_ata
     {
@@ -800,7 +890,6 @@ mod tests {
             close_token_account_when_sell: None,
             fee_recipient: global_constants::FEE_RECIPIENT,
             quote_mint: Pubkey::default(),
-            use_v2_ix: false,
         };
 
         SwapParams {
@@ -837,7 +926,6 @@ mod tests {
             check_min_tip: false,
             grpc_recv_us: None,
             use_exact_sol_amount: Some(true),
-            use_pumpfun_v2: false,
         }
     }
 
@@ -853,14 +941,24 @@ mod tests {
     fn pump_suffix_buy_respects_explicit_legacy_token_program() {
         crate::common::seed::set_default_rents();
         let params = swap_params_for_buy(pump_mint(), TOKEN_PROGRAM);
-        let instructions = build_buy_v1(&params).unwrap();
+        let instructions = build_buy(&params).unwrap();
 
         assert_eq!(instructions.len(), 3);
         assert_eq!(instructions[2].accounts[8].pubkey, TOKEN_PROGRAM);
+        assert_eq!(instructions[1].program_id, TOKEN_PROGRAM);
         assert_eq!(instructions[2].accounts.len(), 18);
         assert_eq!(instructions[2].data.len(), 25);
     }
 
+    #[test]
+    fn non_pump_buy_respects_explicit_legacy_token_program() {
+        crate::common::seed::set_default_rents();
+        let params = swap_params_for_buy(Pubkey::new_unique(), TOKEN_PROGRAM);
+        let instructions = build_buy(&params).unwrap();
+
+        assert_eq!(instructions[2].accounts[8].pubkey, TOKEN_PROGRAM);
+    }
+
     #[test]
     fn pumpfun_v1_fixed_output_uses_buy_with_max_input_budget() {
         let mut params = swap_params_for_buy(pump_mint(), TOKEN_PROGRAM);
@@ -868,7 +966,7 @@ mod tests {
         params.fixed_output_amount = Some(42);
         params.use_exact_sol_amount = Some(true);
 
-        let instructions = build_buy_v1(&params).unwrap();
+        let instructions = build_buy(&params).unwrap();
         let ix = instructions.last().unwrap();
 
         assert_eq!(&ix.data[..8], crate::instruction::utils::pumpfun::BUY_DISCRIMINATOR);
@@ -887,8 +985,12 @@ mod tests {
         params.create_output_mint_ata = false;
         params.fixed_output_amount = Some(42);
         params.use_exact_sol_amount = Some(true);
+        if let DexParamEnum::PumpFun(protocol_params) = &mut params.protocol_params {
+            *protocol_params =
+                protocol_params.clone().with_quote_mint(crate::constants::WSOL_TOKEN_ACCOUNT);
+        }
 
-        let instructions = build_buy_v2(&params).unwrap();
+        let instructions = build_buy(&params).unwrap();
         let ix = instructions.last().unwrap();
 
         assert_eq!(&ix.data[..8], crate::instruction::utils::pumpfun::BUY_V2_DISCRIMINATOR);
@@ -905,8 +1007,12 @@ mod tests {
         params.create_output_mint_ata = false;
         params.create_input_mint_ata = true;
         params.use_exact_sol_amount = Some(false);
+        if let DexParamEnum::PumpFun(protocol_params) = &mut params.protocol_params {
+            *protocol_params =
+                protocol_params.clone().with_quote_mint(crate::constants::WSOL_TOKEN_ACCOUNT);
+        }
 
-        let instructions = build_buy_v2(&params).unwrap();
+        let instructions = build_buy(&params).unwrap();
         let transfer_ix = &instructions[1];
         let system_ix = bincode::deserialize::<
             solana_system_interface::instruction::SystemInstruction,
@@ -925,6 +1031,221 @@ mod tests {
         }
     }
 
+    #[test]
+    fn pumpfun_usdc_dev_trade_uses_usdc_initial_quote_reserves() {
+        let mint = pump_mint();
+        let dev_quote_amount = 707_080;
+        let params = PumpFunParams::from_dev_trade_with_quote_mint(
+            mint,
+            55_855_975_892_641,
+            dev_quote_amount,
+            Pubkey::new_unique(),
+            Pubkey::default(),
+            Pubkey::default(),
+            Pubkey::default(),
+            None,
+            global_constants::FEE_RECIPIENT,
+            TOKEN_PROGRAM,
+            false,
+            Some(false),
+            crate::constants::USDC_TOKEN_ACCOUNT,
+        );
+
+        assert_eq!(params.quote_mint, crate::constants::USDC_TOKEN_ACCOUNT);
+        assert_eq!(params.bonding_curve.quote_mint, crate::constants::USDC_TOKEN_ACCOUNT);
+        assert_eq!(
+            params.bonding_curve.virtual_sol_reserves,
+            global_constants::INITIAL_VIRTUAL_USDC_RESERVES + dev_quote_amount
+        );
+    }
+
+    #[test]
+    fn pumpfun_with_quote_mint_adjusts_dev_trade_quote_reserves() {
+        let mint = pump_mint();
+        let dev_quote_amount = 707_080;
+        let params = PumpFunParams::from_dev_trade(
+            mint,
+            55_855_975_892_641,
+            dev_quote_amount,
+            Pubkey::new_unique(),
+            Pubkey::default(),
+            Pubkey::default(),
+            Pubkey::default(),
+            None,
+            global_constants::FEE_RECIPIENT,
+            TOKEN_PROGRAM,
+            false,
+            Some(false),
+        )
+        .with_quote_mint(crate::constants::USDC_TOKEN_ACCOUNT);
+
+        assert_eq!(
+            params.bonding_curve.virtual_sol_reserves,
+            global_constants::INITIAL_VIRTUAL_USDC_RESERVES + dev_quote_amount
+        );
+    }
+
+    #[test]
+    fn pumpfun_usdc_trade_event_preserves_virtual_quote_reserves() {
+        let mint = pump_mint();
+        let virtual_quote_reserves = 4_527_693_121;
+        let real_quote_reserves = 235_693_121;
+        let params = PumpFunParams::from_trade(
+            Pubkey::default(),
+            Pubkey::default(),
+            mint,
+            crate::constants::USDC_TOKEN_ACCOUNT,
+            Pubkey::new_unique(),
+            Pubkey::default(),
+            944_144_024_107_359,
+            virtual_quote_reserves,
+            737_244_024_107_359,
+            real_quote_reserves,
+            None,
+            global_constants::FEE_RECIPIENT,
+            TOKEN_PROGRAM,
+            false,
+            Some(false),
+        );
+
+        assert_eq!(params.quote_mint, crate::constants::USDC_TOKEN_ACCOUNT);
+        assert_eq!(params.bonding_curve.virtual_quote_reserves(), virtual_quote_reserves);
+        assert_eq!(params.bonding_curve.real_quote_reserves(), real_quote_reserves);
+    }
+
+    #[test]
+    fn pumpfun_solscan_sol_quote_mint_keeps_legacy_layout() {
+        let mint = pump_mint();
+        let params = PumpFunParams::from_trade(
+            Pubkey::default(),
+            Pubkey::default(),
+            mint,
+            crate::constants::SOL_TOKEN_ACCOUNT,
+            Pubkey::new_unique(),
+            Pubkey::default(),
+            944_144_024_107_359,
+            30_235_693_121,
+            737_244_024_107_359,
+            235_693_121,
+            None,
+            global_constants::FEE_RECIPIENT,
+            TOKEN_PROGRAM,
+            false,
+            Some(false),
+        );
+
+        assert_eq!(params.quote_mint, Pubkey::default());
+        assert_eq!(params.bonding_curve.quote_mint, crate::constants::WSOL_TOKEN_ACCOUNT);
+    }
+
+    #[test]
+    fn pumpfun_with_solscan_sol_quote_mint_selects_v1() {
+        let mut params = swap_params_for_buy(pump_mint(), TOKEN_PROGRAM);
+        params.create_output_mint_ata = false;
+        if let DexParamEnum::PumpFun(protocol_params) = &mut params.protocol_params {
+            *protocol_params =
+                protocol_params.clone().with_quote_mint(crate::constants::SOL_TOKEN_ACCOUNT);
+            assert_eq!(protocol_params.quote_mint, Pubkey::default());
+            assert_eq!(
+                protocol_params.bonding_curve.quote_mint,
+                crate::constants::WSOL_TOKEN_ACCOUNT
+            );
+        }
+
+        let ix = build_buy(&params).unwrap().pop().unwrap();
+        assert_eq!(
+            &ix.data[..8],
+            crate::instruction::utils::pumpfun::BUY_EXACT_SOL_IN_DISCRIMINATOR
+        );
+        assert_eq!(ix.accounts.len(), 18);
+    }
+
+    #[test]
+    fn pumpfun_v2_usdc_buy_rejects_sol_input() {
+        let mut params = swap_params_for_buy(pump_mint(), TOKEN_PROGRAM);
+        params.create_output_mint_ata = false;
+        params.input_mint = crate::constants::SOL_TOKEN_ACCOUNT;
+        if let DexParamEnum::PumpFun(protocol_params) = &mut params.protocol_params {
+            *protocol_params =
+                protocol_params.clone().with_quote_mint(crate::constants::USDC_TOKEN_ACCOUNT);
+        }
+
+        let err = build_buy(&params).unwrap_err().to_string();
+        assert!(err.contains("USDC quote pools must be bought with USDC"));
+    }
+
+    #[test]
+    fn pumpfun_usdc_quote_mint_selects_v2_without_global_flag() {
+        let mut params = swap_params_for_buy(pump_mint(), TOKEN_PROGRAM);
+        params.create_output_mint_ata = false;
+        params.input_mint = crate::constants::USDC_TOKEN_ACCOUNT;
+        if let DexParamEnum::PumpFun(protocol_params) = &mut params.protocol_params {
+            *protocol_params =
+                protocol_params.clone().with_quote_mint(crate::constants::USDC_TOKEN_ACCOUNT);
+        }
+
+        let ix = build_buy(&params).unwrap().pop().unwrap();
+        assert_eq!(
+            &ix.data[..8],
+            crate::instruction::utils::pumpfun::BUY_EXACT_QUOTE_IN_V2_DISCRIMINATOR
+        );
+        assert_eq!(ix.accounts.len(), 27);
+    }
+
+    #[test]
+    fn pumpfun_v2_usdc_buy_uses_idl_accounts_17_18_19() {
+        let mint = pump_mint();
+        let mut params = swap_params_for_buy(mint, TOKEN_PROGRAM);
+        params.create_output_mint_ata = false;
+        params.input_mint = crate::constants::USDC_TOKEN_ACCOUNT;
+        if let DexParamEnum::PumpFun(protocol_params) = &mut params.protocol_params {
+            *protocol_params =
+                protocol_params.clone().with_quote_mint(crate::constants::USDC_TOKEN_ACCOUNT);
+        }
+
+        let associated_creator_vault =
+            if let DexParamEnum::PumpFun(protocol_params) = &params.protocol_params {
+                crate::common::fast_fn::get_associated_token_address_with_program_id_fast(
+                    &protocol_params.creator_vault,
+                    &crate::constants::USDC_TOKEN_ACCOUNT,
+                    &crate::constants::TOKEN_PROGRAM,
+                )
+            } else {
+                Pubkey::default()
+            };
+        let ix = build_buy(&params).unwrap().pop().unwrap();
+        assert_eq!(ix.accounts.len(), 27);
+        assert_eq!(ix.accounts[17].pubkey, associated_creator_vault);
+        assert_eq!(
+            ix.accounts[18].pubkey,
+            crate::instruction::utils::pumpfun::get_fee_sharing_config_pda(&mint).unwrap()
+        );
+        assert_eq!(ix.accounts[19].pubkey, accounts::GLOBAL_VOLUME_ACCUMULATOR);
+        assert_eq!(ix.accounts[22].pubkey, accounts::FEE_CONFIG);
+    }
+
+    #[test]
+    fn pumpfun_v2_buyback_fee_recipient_is_writable() {
+        let mint = pump_mint();
+        let mut params = swap_params_for_buy(mint, TOKEN_PROGRAM);
+        params.create_output_mint_ata = false;
+        if let DexParamEnum::PumpFun(protocol_params) = &mut params.protocol_params {
+            *protocol_params =
+                protocol_params.clone().with_quote_mint(crate::constants::WSOL_TOKEN_ACCOUNT);
+        }
+
+        let buy_ix = build_buy(&params).unwrap().pop().unwrap();
+        assert!(global_constants::BUYBACK_FEE_RECIPIENTS.contains(&buy_ix.accounts[8].pubkey));
+        assert!(buy_ix.accounts[8].is_writable);
+
+        params.trade_type = crate::swqos::TradeType::Sell;
+        params.input_mint = mint;
+        params.output_mint = crate::constants::SOL_TOKEN_ACCOUNT;
+        let sell_ix = build_sell(&params).unwrap().pop().unwrap();
+        assert!(global_constants::BUYBACK_FEE_RECIPIENTS.contains(&sell_ix.accounts[8].pubkey));
+        assert!(sell_ix.accounts[8].is_writable);
+    }
+
     #[test]
     fn pumpfun_v1_sell_fixed_output_uses_min_sol_directly() {
         let mint = pump_mint();
@@ -935,7 +1256,7 @@ mod tests {
         params.create_output_mint_ata = false;
         params.fixed_output_amount = Some(42);
 
-        let instructions = build_sell_v1(&params).unwrap();
+        let instructions = build_sell(&params).unwrap();
         let ix = instructions.last().unwrap();
 
         assert_eq!(&ix.data[..8], crate::instruction::utils::pumpfun::SELL_DISCRIMINATOR);
@@ -956,8 +1277,12 @@ mod tests {
         params.output_mint = crate::constants::SOL_TOKEN_ACCOUNT;
         params.create_output_mint_ata = false;
         params.fixed_output_amount = Some(42);
+        if let DexParamEnum::PumpFun(protocol_params) = &mut params.protocol_params {
+            *protocol_params =
+                protocol_params.clone().with_quote_mint(crate::constants::WSOL_TOKEN_ACCOUNT);
+        }
 
-        let instructions = build_sell_v2(&params).unwrap();
+        let instructions = build_sell(&params).unwrap();
         let ix = instructions.last().unwrap();
 
         assert_eq!(&ix.data[..8], crate::instruction::utils::pumpfun::SELL_V2_DISCRIMINATOR);

src/instruction/pumpfun_ix_data.rs

@@ -1,5 +1,6 @@
-//! Pump.fun 曲线 **legacy** `buy` / `buy_exact_sol_in` / `sell` 与 **`buy_v2` / `sell_v2` / `buy_exact_quote_in_v2`**
-//! 的 instruction data 栈上编码（热路径零堆分配）。
+//! Pump.fun bonding-curve `buy` / `buy_exact_quote_in` / `sell`
+//! instruction data stack encoding. The public helper names are version-neutral;
+//! [`PumpFunIxVersion`] selects the legacy or V2 on-chain discriminator.
 //!
 //! Legacy `buy` / `buy_exact_sol_in` 与 `@pump-fun/pump-sdk` 对齐：`OptionBool` 是单字段
 //! struct（TypeScript 传 `[true]`），在 ix 参数中为 1 字节 bool，共 25 字节 ix data。
@@ -10,71 +11,90 @@ use crate::instruction::utils::pumpfun::{
     BUY_V2_DISCRIMINATOR, SELL_DISCRIMINATOR, SELL_V2_DISCRIMINATOR,
 };
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum PumpFunIxVersion {
+    Legacy { track_volume: u8 },
+    V2,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum PumpFunIxData {
+    Bytes25([u8; 25]),
+    Bytes24([u8; 24]),
+}
+
+impl PumpFunIxData {
+    #[inline(always)]
+    pub(crate) fn as_slice(&self) -> &[u8] {
+        match self {
+            Self::Bytes25(data) => data,
+            Self::Bytes24(data) => data,
+        }
+    }
+}
+
 #[inline(always)]
-pub fn encode_pumpfun_buy_ix_data(
+pub(crate) fn encode_pumpfun_buy_ix_data(
     token_amount: u64,
-    max_sol_cost: u64,
-    track_volume_val: u8,
-) -> [u8; 25] {
-    let mut d = [0u8; 25];
-    d[..8].copy_from_slice(&BUY_DISCRIMINATOR);
-    d[8..16].copy_from_slice(&token_amount.to_le_bytes());
-    d[16..24].copy_from_slice(&max_sol_cost.to_le_bytes());
-    d[24] = track_volume_val;
-    d
+    max_quote_cost: u64,
+    version: PumpFunIxVersion,
+) -> PumpFunIxData {
+    match version {
+        PumpFunIxVersion::Legacy { track_volume } => {
+            let mut d = [0u8; 25];
+            d[..8].copy_from_slice(&BUY_DISCRIMINATOR);
+            d[8..16].copy_from_slice(&token_amount.to_le_bytes());
+            d[16..24].copy_from_slice(&max_quote_cost.to_le_bytes());
+            d[24] = track_volume;
+            PumpFunIxData::Bytes25(d)
+        }
+        PumpFunIxVersion::V2 => {
+            let mut d = [0u8; 24];
+            d[..8].copy_from_slice(&BUY_V2_DISCRIMINATOR);
+            d[8..16].copy_from_slice(&token_amount.to_le_bytes());
+            d[16..24].copy_from_slice(&max_quote_cost.to_le_bytes());
+            PumpFunIxData::Bytes24(d)
+        }
+    }
 }
 
 #[inline(always)]
-pub fn encode_pumpfun_buy_exact_sol_in_ix_data(
-    spendable_sol_in: u64,
-    min_tokens_out: u64,
-    track_volume_val: u8,
-) -> [u8; 25] {
-    let mut d = [0u8; 25];
-    d[..8].copy_from_slice(&BUY_EXACT_SOL_IN_DISCRIMINATOR);
-    d[8..16].copy_from_slice(&spendable_sol_in.to_le_bytes());
-    d[16..24].copy_from_slice(&min_tokens_out.to_le_bytes());
-    d[24] = track_volume_val;
-    d
-}
-
-#[inline(always)]
-pub fn encode_pumpfun_sell_ix_data(token_amount: u64, min_sol_output: u64) -> [u8; 24] {
-    let mut d = [0u8; 24];
-    d[..8].copy_from_slice(&SELL_DISCRIMINATOR);
-    d[8..16].copy_from_slice(&token_amount.to_le_bytes());
-    d[16..24].copy_from_slice(&min_sol_output.to_le_bytes());
-    d
-}
-
-// --- v2 instruction data encoders (no track_volume arg — 2 args each, 24 bytes total) ---
-
-#[inline(always)]
-pub fn encode_pumpfun_buy_v2_ix_data(amount: u64, max_sol_cost: u64) -> [u8; 24] {
-    let mut d = [0u8; 24];
-    d[..8].copy_from_slice(&BUY_V2_DISCRIMINATOR);
-    d[8..16].copy_from_slice(&amount.to_le_bytes());
-    d[16..24].copy_from_slice(&max_sol_cost.to_le_bytes());
-    d
-}
-
-#[inline(always)]
-pub fn encode_pumpfun_buy_exact_quote_in_v2_ix_data(
+pub(crate) fn encode_pumpfun_buy_exact_quote_in_ix_data(
     spendable_quote_in: u64,
     min_tokens_out: u64,
-) -> [u8; 24] {
-    let mut d = [0u8; 24];
-    d[..8].copy_from_slice(&BUY_EXACT_QUOTE_IN_V2_DISCRIMINATOR);
-    d[8..16].copy_from_slice(&spendable_quote_in.to_le_bytes());
-    d[16..24].copy_from_slice(&min_tokens_out.to_le_bytes());
-    d
+    version: PumpFunIxVersion,
+) -> PumpFunIxData {
+    match version {
+        PumpFunIxVersion::Legacy { track_volume } => {
+            let mut d = [0u8; 25];
+            d[..8].copy_from_slice(&BUY_EXACT_SOL_IN_DISCRIMINATOR);
+            d[8..16].copy_from_slice(&spendable_quote_in.to_le_bytes());
+            d[16..24].copy_from_slice(&min_tokens_out.to_le_bytes());
+            d[24] = track_volume;
+            PumpFunIxData::Bytes25(d)
+        }
+        PumpFunIxVersion::V2 => {
+            let mut d = [0u8; 24];
+            d[..8].copy_from_slice(&BUY_EXACT_QUOTE_IN_V2_DISCRIMINATOR);
+            d[8..16].copy_from_slice(&spendable_quote_in.to_le_bytes());
+            d[16..24].copy_from_slice(&min_tokens_out.to_le_bytes());
+            PumpFunIxData::Bytes24(d)
+        }
+    }
 }
 
 #[inline(always)]
-pub fn encode_pumpfun_sell_v2_ix_data(token_amount: u64, min_sol_output: u64) -> [u8; 24] {
+pub(crate) fn encode_pumpfun_sell_ix_data(
+    token_amount: u64,
+    min_quote_output: u64,
+    version: PumpFunIxVersion,
+) -> PumpFunIxData {
     let mut d = [0u8; 24];
-    d[..8].copy_from_slice(&SELL_V2_DISCRIMINATOR);
+    d[..8].copy_from_slice(match version {
+        PumpFunIxVersion::Legacy { .. } => &SELL_DISCRIMINATOR,
+        PumpFunIxVersion::V2 => &SELL_V2_DISCRIMINATOR,
+    });
     d[8..16].copy_from_slice(&token_amount.to_le_bytes());
-    d[16..24].copy_from_slice(&min_sol_output.to_le_bytes());
-    d
+    d[16..24].copy_from_slice(&min_quote_output.to_le_bytes());
+    PumpFunIxData::Bytes24(d)
 }

src/instruction/pumpswap.rs

@@ -596,7 +596,6 @@ mod tests {
             check_min_tip: false,
             grpc_recv_us: None,
             use_exact_sol_amount: Some(true),
-            use_pumpfun_v2: false,
         }
     }
 

src/instruction/raydium_amm_v4.rs

@@ -389,7 +389,6 @@ mod tests {
             check_min_tip: false,
             grpc_recv_us: None,
             use_exact_sol_amount: None,
-            use_pumpfun_v2: false,
         }
     }
 

src/instruction/raydium_cpmm.rs

@@ -401,7 +401,6 @@ mod tests {
             check_min_tip: false,
             grpc_recv_us: None,
             use_exact_sol_amount: None,
-            use_pumpfun_v2: false,
         }
     }
 

src/instruction/utils/pumpfun.rs

@@ -39,6 +39,7 @@ pub mod global_constants {
 
     pub const INITIAL_VIRTUAL_TOKEN_RESERVES: u64 = 1_073_000_000_000_000;
     pub const INITIAL_VIRTUAL_SOL_RESERVES: u64 = 30_000_000_000;
+    pub const INITIAL_VIRTUAL_USDC_RESERVES: u64 = 4_292_000_000;
     pub const INITIAL_REAL_TOKEN_RESERVES: u64 = 793_100_000_000_000;
     pub const TOKEN_TOTAL_SUPPLY: u64 = 1_000_000_000_000_000;
     pub const FEE_BASIS_POINTS: u64 = 95;
@@ -212,7 +213,7 @@ pub fn is_amm_fee_recipient(pubkey: &Pubkey) -> bool {
 
 #[inline]
 pub fn is_standard_bonding_fee_recipient(pubkey: &Pubkey) -> bool {
-    *pubkey == global_constants::FEE_RECIPIENT || is_amm_fee_recipient(pubkey)
+    *pubkey == global_constants::FEE_RECIPIENT
 }
 
 #[inline]
@@ -242,11 +243,12 @@ pub fn reconcile_mayhem_mode_for_trade(
 #[inline]
 pub fn fee_recipient_ok_for_bonding_curve_mode(pk: &Pubkey, is_mayhem_mode: bool) -> bool {
     let is_m = is_mayhem_fee_recipient(pk);
+    let is_amm = is_amm_fee_recipient(pk);
     let is_s = is_standard_bonding_fee_recipient(pk);
     if is_mayhem_mode {
-        !(is_s && !is_m)
+        is_m || (!is_s && !is_amm && *pk != Pubkey::default())
     } else {
-        !(is_m && !is_s)
+        is_s || (!is_m && !is_amm && *pk != Pubkey::default())
     }
 }
 
@@ -260,18 +262,10 @@ pub fn get_mayhem_fee_recipient_meta_random() -> AccountMeta {
 
 #[inline]
 pub fn get_standard_fee_recipient_meta_random() -> AccountMeta {
-    const POOL: &[Pubkey] = &[
-        global_constants::FEE_RECIPIENT,
-        global_constants::PUMPFUN_AMM_FEE_1,
-        global_constants::PUMPFUN_AMM_FEE_2,
-        global_constants::PUMPFUN_AMM_FEE_3,
-        global_constants::PUMPFUN_AMM_FEE_4,
-        global_constants::PUMPFUN_AMM_FEE_5,
-        global_constants::PUMPFUN_AMM_FEE_6,
-        global_constants::PUMPFUN_AMM_FEE_7,
-    ];
-    let recipient = *POOL.choose(&mut rand::rng()).unwrap_or(&global_constants::FEE_RECIPIENT);
-    AccountMeta { pubkey: recipient, is_signer: false, is_writable: true }
+    // Historical name kept for API compatibility. Do not randomize across static AMM fee
+    // recipients for bonding-curve buy/sell; stale AMM protocol fee accounts can fail
+    // Pump.fun authorization with error 6000 when Global has rotated.
+    AccountMeta { pubkey: global_constants::FEE_RECIPIENT, is_signer: false, is_writable: true }
 }
 
 #[inline]
@@ -707,12 +701,12 @@ mod tests {
 
     #[test]
     fn reconcile_mayhem_prefers_fee_when_log_says_true_but_fee_is_standard_pool() {
-        let fee = global_constants::PUMPFUN_AMM_FEE_4;
+        let fee = global_constants::FEE_RECIPIENT;
         assert!(!reconcile_mayhem_mode_for_trade(Some(true), &fee));
     }
 
     #[test]
-    fn pump_fee_meta_rejects_standard_fee_when_building_mayhem_ix() {
+    fn pump_fee_meta_rejects_amm_fee_when_building_mayhem_ix() {
         let fee = global_constants::PUMPFUN_AMM_FEE_4;
         let m = pump_fun_fee_recipient_meta(fee, true);
         assert!(
@@ -723,11 +717,28 @@ mod tests {
     }
 
     #[test]
-    fn pump_fee_meta_uses_observed_standard_fee_for_standard_ix() {
-        let fee = global_constants::PUMPFUN_AMM_FEE_7;
+    fn pump_fee_meta_uses_observed_non_amm_fee_for_standard_ix() {
+        let fee = Pubkey::new_unique();
         let m = pump_fun_fee_recipient_meta(fee, false);
         assert_eq!(m.pubkey, fee);
         assert!(m.is_writable);
         assert!(!m.is_signer);
     }
+
+    #[test]
+    fn pump_fee_meta_rejects_amm_fee_for_standard_ix() {
+        let fee = global_constants::PUMPFUN_AMM_FEE_7;
+        let m = pump_fun_fee_recipient_meta(fee, false);
+        assert_eq!(m.pubkey, global_constants::FEE_RECIPIENT);
+        assert!(m.is_writable);
+        assert!(!m.is_signer);
+    }
+
+    #[test]
+    fn pump_fee_meta_default_standard_uses_main_fee_recipient() {
+        let m = pump_fun_fee_recipient_meta(Pubkey::default(), false);
+        assert_eq!(m.pubkey, global_constants::FEE_RECIPIENT);
+        assert!(m.is_writable);
+        assert!(!m.is_signer);
+    }
 }

src/trading/common/compute_budget_manager.rs

@@ -3,7 +3,9 @@ use once_cell::sync::Lazy;
 use smallvec::SmallVec;
 use solana_compute_budget_interface::ComputeBudgetInstruction;
 use solana_sdk::instruction::Instruction;
-use std::sync::Arc;
+use std::{hash::Hash, sync::Arc};
+
+const MAX_COMPUTE_BUDGET_CACHE_SIZE: usize = 4_096;
 
 /// Cache key containing all parameters for compute budget instructions
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -17,6 +19,22 @@ struct ComputeBudgetCacheKey {
 static COMPUTE_BUDGET_CACHE: Lazy<DashMap<ComputeBudgetCacheKey, Arc<SmallVec<[Instruction; 2]>>>> =
     Lazy::new(|| DashMap::new());
 
+#[inline]
+fn prune_cache<K, V>(cache: &DashMap<K, V>, max_size: usize)
+where
+    K: Eq + Hash + Clone,
+{
+    let len = cache.len();
+    if len <= max_size {
+        return;
+    }
+    let remove_count = (len - max_size).max(max_size / 16).min(len);
+    let keys: Vec<K> = cache.iter().take(remove_count).map(|entry| entry.key().clone()).collect();
+    for key in keys {
+        cache.remove(&key);
+    }
+}
+
 /// Extend `instructions` with compute budget instructions; on cache hit extends from cached Arc (no SmallVec clone).
 #[inline(always)]
 pub fn extend_compute_budget_instructions(
@@ -41,6 +59,7 @@ pub fn extend_compute_budget_instructions(
     let arc = Arc::new(insts);
     instructions.extend(arc.iter().cloned());
     COMPUTE_BUDGET_CACHE.insert(cache_key, arc);
+    prune_cache(&COMPUTE_BUDGET_CACHE, MAX_COMPUTE_BUDGET_CACHE_SIZE);
 }
 
 /// Returns compute budget instructions (allocates on cache hit; prefer `extend_compute_budget_instructions` on hot path).
@@ -59,5 +78,6 @@ pub fn compute_budget_instructions(unit_price: u64, unit_limit: u32) -> SmallVec
     }
     let arc = Arc::new(insts.clone());
     COMPUTE_BUDGET_CACHE.insert(cache_key, arc);
+    prune_cache(&COMPUTE_BUDGET_CACHE, MAX_COMPUTE_BUDGET_CACHE_SIZE);
     insts
 }

src/trading/common/transaction_builder.rs

@@ -1,3 +1,4 @@
+use anyhow::anyhow;
 use solana_hash::Hash;
 use solana_message::AddressLookupTableAccount;
 use solana_sdk::{
@@ -93,19 +94,19 @@ fn build_versioned_transaction(
     // 使用预分配的交易构建器以降低延迟
     let mut builder = acquire_builder();
 
-    let versioned_msg = builder.build_zero_alloc(
+    let build_result = builder.build_zero_alloc(
         &payer.pubkey(),
         &full_instructions,
         address_lookup_table_account,
         blockhash,
     );
+    release_builder(builder);
+    let versioned_msg = build_result?;
 
     let msg_bytes = versioned_msg.serialize();
-    let signature = payer.as_ref().try_sign_message(&msg_bytes).expect("sign failed");
+    let signature =
+        payer.as_ref().try_sign_message(&msg_bytes).map_err(|e| anyhow!("sign failed: {e}"))?;
     let tx = VersionedTransaction { signatures: vec![signature], message: versioned_msg };
 
-    // 归还构建器到池
-    release_builder(builder);
-
     Ok(tx)
 }

src/trading/core/async_executor.rs

@@ -35,8 +35,8 @@ use fnv::FnvHasher;
 type FnvHashMap<K, V> = HashMap<K, V, BuildHasherDefault<FnvHasher>>;
 
 use crate::{
-    common::nonce_cache::DurableNonceInfo,
-    common::GasFeeStrategy,
+    common::gas_fee_strategy::{GasFeeStrategyType, GasFeeStrategyValue},
+    common::{nonce_cache::DurableNonceInfo, GasFeeStrategy, SwqosSubmitTiming},
     swqos::{SwqosClient, SwqosType, TradeType},
     trading::core::params::SenderConcurrencyConfig,
     trading::{common::build_transaction, MiddlewareManager},
@@ -46,6 +46,7 @@ use crate::{
 const SWQOS_POOL_WORKERS: usize = 18;
 const SWQOS_QUEUE_CAP: usize = 128;
 const SWQOS_DEDICATED_DEFAULT_THREADS: usize = 18;
+const FAST_SUBMIT_RESULT_TIMEOUT: Duration = Duration::from_secs(5);
 
 /// Shared across all jobs in one batch; built once, cloned as single Arc per job (minimal hot-path clone).
 struct SwqosSharedContext {
@@ -71,6 +72,7 @@ struct SwqosJob {
     tip_account: Arc<Pubkey>,
     swqos_client: Arc<SwqosClient>,
     swqos_type: SwqosType,
+    strategy_type: GasFeeStrategyType,
     core_id: Option<core_affinity::CoreId>,
     use_affinity: bool,
 }
@@ -107,6 +109,7 @@ async fn run_one_swqos_job(job: SwqosJob) {
                 signature: Signature::default(),
                 error: Some(e),
                 swqos_type: job.swqos_type,
+                strategy_type: job.strategy_type,
                 landed_on_chain: false,
                 submit_done_us: crate::common::clock::now_micros(),
             });
@@ -136,6 +139,7 @@ async fn run_one_swqos_job(job: SwqosJob) {
         signature: sig,
         error: err,
         swqos_type: job.swqos_type,
+        strategy_type: job.strategy_type,
         landed_on_chain,
         submit_done_us: crate::common::clock::now_micros(),
     });
@@ -153,33 +157,31 @@ async fn swqos_worker_loop(queue: Arc<ArrayQueue<SwqosJob>>, notify: Arc<Notify>
 
 static SWQOS_QUEUE: OnceCell<Arc<ArrayQueue<SwqosJob>>> = OnceCell::new();
 static SWQOS_NOTIFY: OnceCell<Arc<Notify>> = OnceCell::new();
-static SWQOS_WORKERS_STARTED: AtomicBool = AtomicBool::new(false);
+static SWQOS_WORKER_COUNT: AtomicUsize = AtomicUsize::new(0);
 
 /// Dedicated OS-thread sender pool. Queue and notify are in OnceCell so hot path never takes a lock after init.
 static DEDICATED_QUEUE: OnceCell<Arc<ArrayQueue<SwqosJob>>> = OnceCell::new();
 static DEDICATED_NOTIFY: OnceCell<Arc<Notify>> = OnceCell::new();
+static DEDICATED_WORKER_COUNT: AtomicUsize = AtomicUsize::new(0);
 /// JoinHandles kept so dedicated threads are not detached; only touched during init under lock.
 static DEDICATED_INIT: Mutex<Option<Vec<std::thread::JoinHandle<()>>>> = Mutex::new(None);
 
-fn ensure_dedicated_pool(
+fn desired_dedicated_workers(
     sender_thread_cores: Option<&[usize]>,
     max_sender_concurrency: usize,
-) -> (Arc<ArrayQueue<SwqosJob>>, Arc<Notify>) {
-    if let (Some(q), Some(n)) = (DEDICATED_QUEUE.get(), DEDICATED_NOTIFY.get()) {
-        return (q.clone(), n.clone());
-    }
-    let mut guard = DEDICATED_INIT.lock();
-    if let (Some(q), Some(n)) = (DEDICATED_QUEUE.get(), DEDICATED_NOTIFY.get()) {
-        return (q.clone(), n.clone());
-    }
-    let n = sender_thread_cores
+) -> usize {
+    sender_thread_cores
         .map(|v| v.len().min(max_sender_concurrency))
         .unwrap_or_else(|| SWQOS_DEDICATED_DEFAULT_THREADS.min(max_sender_concurrency))
         .min(32)
-        .max(1);
-    let queue = Arc::new(ArrayQueue::new(SWQOS_QUEUE_CAP));
-    let notify = Arc::new(Notify::new());
-    let core_ids: Vec<core_affinity::CoreId> = core_affinity::get_core_ids()
+        .max(1)
+}
+
+fn dedicated_core_ids(
+    sender_thread_cores: Option<&[usize]>,
+    n: usize,
+) -> Vec<core_affinity::CoreId> {
+    core_affinity::get_core_ids()
         .map(|all_ids| {
             sender_thread_cores
                 .map(|indices| {
@@ -187,9 +189,83 @@ fn ensure_dedicated_pool(
                 })
                 .unwrap_or_else(|| all_ids.into_iter().take(n).collect())
         })
-        .unwrap_or_default();
-    let mut handles = Vec::with_capacity(n);
-    for i in 0..n {
+        .unwrap_or_default()
+}
+
+fn ensure_dedicated_pool(
+    sender_thread_cores: Option<&[usize]>,
+    max_sender_concurrency: usize,
+) -> (Arc<ArrayQueue<SwqosJob>>, Arc<Notify>) {
+    let target_workers = desired_dedicated_workers(sender_thread_cores, max_sender_concurrency);
+    if let (Some(q), Some(n)) = (DEDICATED_QUEUE.get(), DEDICATED_NOTIFY.get()) {
+        if DEDICATED_WORKER_COUNT.load(Ordering::Acquire) >= target_workers {
+            return (q.clone(), n.clone());
+        }
+        ensure_dedicated_worker_count(q.clone(), n.clone(), sender_thread_cores, target_workers);
+        return (q.clone(), n.clone());
+    }
+    let mut guard = DEDICATED_INIT.lock();
+    if let (Some(q), Some(n)) = (DEDICATED_QUEUE.get(), DEDICATED_NOTIFY.get()) {
+        if DEDICATED_WORKER_COUNT.load(Ordering::Acquire) < target_workers {
+            ensure_dedicated_worker_count_locked(
+                q.clone(),
+                n.clone(),
+                sender_thread_cores,
+                target_workers,
+                &mut guard,
+            );
+        }
+        return (q.clone(), n.clone());
+    }
+    let queue = Arc::new(ArrayQueue::new(SWQOS_QUEUE_CAP));
+    let notify = Arc::new(Notify::new());
+    let _ = DEDICATED_QUEUE.set(queue.clone());
+    let _ = DEDICATED_NOTIFY.set(notify.clone());
+    *guard = Some(Vec::with_capacity(target_workers));
+    ensure_dedicated_worker_count_locked(
+        queue.clone(),
+        notify.clone(),
+        sender_thread_cores,
+        target_workers,
+        &mut guard,
+    );
+    (queue, notify)
+}
+
+fn ensure_dedicated_worker_count(
+    queue: Arc<ArrayQueue<SwqosJob>>,
+    notify: Arc<Notify>,
+    sender_thread_cores: Option<&[usize]>,
+    target_workers: usize,
+) {
+    if DEDICATED_WORKER_COUNT.load(Ordering::Acquire) >= target_workers {
+        return;
+    }
+    let mut guard = DEDICATED_INIT.lock();
+    ensure_dedicated_worker_count_locked(
+        queue,
+        notify,
+        sender_thread_cores,
+        target_workers,
+        &mut guard,
+    );
+}
+
+fn ensure_dedicated_worker_count_locked(
+    queue: Arc<ArrayQueue<SwqosJob>>,
+    notify: Arc<Notify>,
+    sender_thread_cores: Option<&[usize]>,
+    target_workers: usize,
+    guard: &mut Option<Vec<std::thread::JoinHandle<()>>>,
+) {
+    let current = DEDICATED_WORKER_COUNT.load(Ordering::Acquire);
+    if current >= target_workers {
+        return;
+    }
+    let core_ids = dedicated_core_ids(sender_thread_cores, target_workers);
+    let handles = guard.get_or_insert_with(Vec::new);
+    handles.reserve(target_workers.saturating_sub(current));
+    for i in current..target_workers {
         let queue = queue.clone();
         let notify = notify.clone();
         let core_id = core_ids.get(i).cloned();
@@ -205,19 +281,23 @@ fn ensure_dedicated_pool(
         });
         handles.push(handle);
     }
-    let _ = DEDICATED_QUEUE.set(queue.clone());
-    let _ = DEDICATED_NOTIFY.set(notify.clone());
-    *guard = Some(handles);
-    (queue, notify)
+    DEDICATED_WORKER_COUNT.store(target_workers, Ordering::Release);
 }
 
 fn ensure_swqos_pool(queue: Arc<ArrayQueue<SwqosJob>>, max_sender_concurrency: usize) {
-    if SWQOS_WORKERS_STARTED.swap(true, Ordering::AcqRel) {
+    let n = SWQOS_POOL_WORKERS.min(max_sender_concurrency).max(1);
+    let mut current = SWQOS_WORKER_COUNT.load(Ordering::Acquire);
+    while current < n {
+        match SWQOS_WORKER_COUNT.compare_exchange(current, n, Ordering::AcqRel, Ordering::Acquire) {
+            Ok(_) => break,
+            Err(actual) => current = actual,
+        }
+    }
+    if current >= n {
         return;
     }
-    let n = SWQOS_POOL_WORKERS.min(max_sender_concurrency).max(1);
     let notify = SWQOS_NOTIFY.get_or_init(|| Arc::new(Notify::new())).clone();
-    for _ in 0..n {
+    for _ in current..n {
         tokio::spawn(swqos_worker_loop(queue.clone(), notify.clone()));
     }
 }
@@ -228,6 +308,7 @@ struct TaskResult {
     signature: Signature,
     error: Option<anyhow::Error>,
     swqos_type: SwqosType,
+    strategy_type: GasFeeStrategyType,
     landed_on_chain: bool,
     /// Microsecond timestamp when this task finished (SWQOS returned); for per-SWQOS event→submit timing.
     submit_done_us: i64,
@@ -295,7 +376,7 @@ impl ResultCollector {
 
     async fn wait_for_success(
         &self,
-    ) -> Option<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<(SwqosType, i64)>)> {
+    ) -> Option<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<SwqosSubmitTiming>)> {
         let start = Instant::now();
         let timeout = std::time::Duration::from_secs(5);
         let poll_interval = std::time::Duration::from_millis(1000);
@@ -307,7 +388,7 @@ impl ResultCollector {
                 let mut submit_timings = Vec::new();
                 while let Some(result) = self.results.pop() {
                     signatures.push(result.signature);
-                    submit_timings.push((result.swqos_type, result.submit_done_us));
+                    submit_timings.push(result.submit_timing());
                     if result.success {
                         has_success = true;
                     }
@@ -325,7 +406,7 @@ impl ResultCollector {
                 let mut submit_timings = Vec::new();
                 while let Some(result) = self.results.pop() {
                     signatures.push(result.signature);
-                    submit_timings.push((result.swqos_type, result.submit_done_us));
+                    submit_timings.push(result.submit_timing());
                     // Prefer the error from the tx that actually landed
                     if result.landed_on_chain && result.error.is_some() {
                         landed_error = result.error;
@@ -344,7 +425,7 @@ impl ResultCollector {
                 let mut submit_timings = Vec::new();
                 while let Some(result) = self.results.pop() {
                     signatures.push(result.signature);
-                    submit_timings.push((result.swqos_type, result.submit_done_us));
+                    submit_timings.push(result.submit_timing());
                     if result.success {
                         any_success = true;
                     }
@@ -367,7 +448,7 @@ impl ResultCollector {
 
     fn get_first(
         &self,
-    ) -> Option<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<(SwqosType, i64)>)> {
+    ) -> Option<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<SwqosSubmitTiming>)> {
         let mut signatures = Vec::new();
         let mut has_success = false;
         let mut last_error = None;
@@ -375,7 +456,7 @@ impl ResultCollector {
 
         while let Some(result) = self.results.pop() {
             signatures.push(result.signature);
-            submit_timings.push((result.swqos_type, result.submit_done_us));
+            submit_timings.push(result.submit_timing());
             if result.success {
                 has_success = true;
             }
@@ -391,12 +472,35 @@ impl ResultCollector {
         }
     }
 
+    /// Fast submit mode for callers that do not wait for on-chain confirmation.
+    /// Return as soon as one route accepts, a landed failure consumes the nonce, all routes finish,
+    /// or the submit result window expires. Slow HTTP routes continue in worker tasks but no longer
+    /// block post-buy monitoring / sell scheduling.
+    async fn wait_for_first_submitted(
+        &self,
+        timeout: Duration,
+    ) -> Option<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<SwqosSubmitTiming>)> {
+        let start = Instant::now();
+        let poll_interval = Duration::from_millis(1);
+        loop {
+            if self.success_flag.load(Ordering::Acquire)
+                || self.landed_failed_flag.load(Ordering::Acquire)
+                || self.completed_count.load(Ordering::Acquire) >= self.total_tasks
+                || start.elapsed() >= timeout
+            {
+                return self.get_first();
+            }
+            tokio::time::sleep(poll_interval).await;
+        }
+    }
+
     /// 等待全部任务完成（不等待链上确认），然后收集并返回所有签名。用于「多路提交」时返回多笔签名。
     /// 轮询间隔 2ms，避免 50ms 间隔在最后一笔返回时多等几十 ms 拉高 submit 耗时。
+    #[allow(dead_code)]
     async fn wait_for_all_submitted(
         &self,
         timeout_secs: u64,
-    ) -> Option<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<(SwqosType, i64)>)> {
+    ) -> Option<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<SwqosSubmitTiming>)> {
         let start = Instant::now();
         let primary = Duration::from_secs(timeout_secs);
         let poll_interval = Duration::from_millis(2);
@@ -410,8 +514,7 @@ impl ResultCollector {
         // 若主窗口到时仍有未回包通道，晚到的 TaskResult 若立刻 drain 会丢签名——仅在该路径上拉长 grace。
         let all_submitted = self.completed_count.load(Ordering::Acquire) >= self.total_tasks;
         if all_submitted {
-            // 全数已登记：仅留极短 settle，避免极端情况下最后一笔与计数可见性竞态。
-            tokio::time::sleep(Duration::from_millis(35)).await;
+            tokio::task::yield_now().await;
         } else {
             tokio::time::sleep(Duration::from_millis(600)).await;
             while self.completed_count.load(Ordering::Acquire) < self.total_tasks {
@@ -426,6 +529,63 @@ impl ResultCollector {
     }
 }
 
+type GasFeeConfig = (SwqosType, GasFeeStrategyType, GasFeeStrategyValue);
+
+#[derive(Debug, Clone, Copy)]
+struct SwqosTaskConfig {
+    task_ordinal: usize,
+    swqos_index: usize,
+    gas_fee_config: GasFeeConfig,
+}
+
+impl TaskResult {
+    #[inline]
+    fn submit_timing(&self) -> SwqosSubmitTiming {
+        SwqosSubmitTiming {
+            swqos_type: self.swqos_type,
+            strategy_type: self.strategy_type,
+            submit_done_us: self.submit_done_us,
+        }
+    }
+}
+
+fn select_swqos_task_configs(
+    swqos_types: &[SwqosType],
+    gas_fee_configs: &[GasFeeConfig],
+    with_tip: bool,
+    check_min_tip: bool,
+    min_tip_by_swqos: impl Fn(SwqosType) -> f64,
+) -> Vec<SwqosTaskConfig> {
+    let mut task_configs = Vec::with_capacity(swqos_types.len() * 3);
+    for (i, swqos_type) in swqos_types.iter().copied().enumerate() {
+        if !with_tip && !matches!(swqos_type, SwqosType::Default) {
+            continue;
+        }
+        let check_tip = with_tip && !matches!(swqos_type, SwqosType::Default) && check_min_tip;
+        let min_tip = if check_tip { min_tip_by_swqos(swqos_type) } else { 0.0 };
+        for config in gas_fee_configs {
+            if config.0 != swqos_type {
+                continue;
+            }
+            if check_tip && config.2.tip < min_tip {
+                if crate::common::sdk_log::sdk_log_enabled() {
+                    println!(
+                        "⚠️ Config filtered: {:?} tip {} is below minimum required {}",
+                        config.0, config.2.tip, min_tip
+                    );
+                }
+                continue;
+            }
+            task_configs.push(SwqosTaskConfig {
+                task_ordinal: task_configs.len(),
+                swqos_index: i,
+                gas_fee_config: *config,
+            });
+        }
+    }
+    task_configs
+}
+
 /// Execute trade on multiple SWQOS clients in parallel; returns success flag, all signatures, and last error.
 ///
 /// `sender_config` merges sender_thread_cores, effective_core_ids, max_sender_concurrency (precomputed at SDK init; no get_core_ids on hot path).
@@ -445,7 +605,7 @@ pub async fn execute_parallel(
     use_dedicated_sender_threads: bool,
     sender_config: SenderConcurrencyConfig,
     check_min_tip: bool,
-) -> Result<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<(SwqosType, i64)>)> {
+) -> Result<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<SwqosSubmitTiming>)> {
     if swqos_clients.is_empty() {
         return Err(anyhow!("swqos_clients is empty"));
     }
@@ -464,47 +624,33 @@ pub async fn execute_parallel(
     // One get_strategies call per batch (avoid N calls in loop).
     let gas_fee_configs =
         gas_fee_strategy.get_strategies(if is_buy { TradeType::Buy } else { TradeType::Sell });
-    let mut task_configs = Vec::with_capacity(swqos_clients.len() * 3);
-    for (i, swqos_client) in swqos_clients.iter().enumerate() {
-        let swqos_type = swqos_client.get_swqos_type();
-        if !with_tip && !matches!(swqos_type, SwqosType::Default) {
-            continue;
-        }
-        let check_tip = with_tip && !matches!(swqos_type, SwqosType::Default) && check_min_tip;
-        let min_tip = if check_tip { swqos_client.min_tip_sol() } else { 0.0 };
-        for config in &gas_fee_configs {
-            if config.0 != swqos_type {
-                continue;
-            }
-            if check_tip {
-                if config.2.tip < min_tip && crate::common::sdk_log::sdk_log_enabled() {
-                    println!(
-                        "⚠️ Config filtered: {:?} tip {} is below minimum required {}",
-                        config.0, config.2.tip, min_tip
-                    );
-                }
-                if config.2.tip < min_tip {
-                    continue;
-                }
-            }
-            task_configs.push((i, swqos_client.clone(), *config));
-        }
-    }
+    let swqos_types: Vec<SwqosType> =
+        swqos_clients.iter().map(|swqos| swqos.get_swqos_type()).collect();
+    let selected_task_configs = select_swqos_task_configs(
+        &swqos_types,
+        &gas_fee_configs,
+        with_tip,
+        check_min_tip,
+        |swqos_type| {
+            swqos_clients
+                .iter()
+                .find(|swqos| swqos.get_swqos_type() == swqos_type)
+                .map(|swqos| swqos.min_tip_sol())
+                .unwrap_or(0.0)
+        },
+    );
 
-    if task_configs.is_empty() {
+    if selected_task_configs.is_empty() {
         return Err(anyhow!("No available gas fee strategy configs"));
     }
 
-    if is_buy && task_configs.len() > 1 && durable_nonce.is_none() {
+    if is_buy && selected_task_configs.len() > 1 && durable_nonce.is_none() {
         return Err(anyhow!("Multiple swqos transactions require durable_nonce to be set.",));
     }
 
     // Task preparation completed: one shared context (clone once per batch), then minimal per-task data.
-    let channel_count = task_configs.len().max(1);
+    let channel_count = selected_task_configs.len().max(1);
     let collector = Arc::new(ResultCollector::new(channel_count));
-    // 上限最多 5s：单路卡死时才会等满；若所有通道在窗口内回完，主循环会提前结束（不睡满秒数）。
-    let submit_timeout_secs: u64 =
-        (3u64 + (channel_count.min(16) as u64).div_ceil(2).min(6)).clamp(3, 5);
     let shared = Arc::new(SwqosSharedContext {
         payer,
         instructions,
@@ -534,10 +680,15 @@ pub async fn execute_parallel(
         let effective_core_ids = sender_config.effective_core_ids.as_slice();
         let core_len = effective_core_ids.len().max(1);
         let mut tip_cache: FnvHashMap<*const (), Arc<Pubkey>> =
-            FnvHashMap::with_capacity_and_hasher(task_configs.len(), BuildHasherDefault::default());
-        for (i, swqos_client, gas_fee_strategy_config) in task_configs {
-            let core_id = effective_core_ids.get(i % core_len).copied();
+            FnvHashMap::with_capacity_and_hasher(
+                selected_task_configs.len(),
+                BuildHasherDefault::default(),
+            );
+        for task_config in selected_task_configs {
+            let swqos_client = swqos_clients[task_config.swqos_index].clone();
+            let core_id = effective_core_ids.get(task_config.task_ordinal % core_len).copied();
             let swqos_type = swqos_client.get_swqos_type();
+            let gas_fee_strategy_config = task_config.gas_fee_config;
             let key = Arc::as_ptr(&swqos_client) as *const ();
             let tip_account = match tip_cache.get(&key) {
                 Some(t) => t.clone(),
@@ -561,10 +712,21 @@ pub async fn execute_parallel(
                 tip_account,
                 swqos_client,
                 swqos_type,
+                strategy_type: gas_fee_strategy_config.1,
                 core_id,
                 use_affinity: !effective_core_ids.is_empty(),
             };
-            let _ = queue.push(job);
+            if let Err(job) = queue.push(job) {
+                shared.collector.submit(TaskResult {
+                    success: false,
+                    signature: Signature::default(),
+                    error: Some(anyhow!("SWQOS sender queue is full")),
+                    swqos_type: job.swqos_type,
+                    strategy_type: job.strategy_type,
+                    landed_on_chain: false,
+                    submit_done_us: crate::common::clock::now_micros(),
+                });
+            }
         }
     }
 
@@ -573,12 +735,10 @@ pub async fn execute_parallel(
     // All jobs enqueued (no spawn on hot path)
 
     if !wait_transaction_confirmed {
-        // submit_timeout_secs 为「等齐各 SWQOS HTTP 应答」的上限；收齐后会立刻进入短 settle，不会睡满整段秒数。
-        // `wait_for_all_submitted` 仅在未收齐时追加长 grace，避免过早 drain 丢晚到签名。
-        let ret = collector.wait_for_all_submitted(submit_timeout_secs).await.unwrap_or((
+        let ret = collector.wait_for_first_submitted(FAST_SUBMIT_RESULT_TIMEOUT).await.unwrap_or((
             false,
             vec![],
-            Some(anyhow!("No SWQOS result within grace window (primary {}s)", submit_timeout_secs)),
+            Some(anyhow!("No SWQOS result within submit result window")),
             vec![],
         ));
         let (success, signatures, last_error, submit_timings) = ret;
@@ -592,3 +752,73 @@ pub async fn execute_parallel(
         Err(anyhow!("All transactions failed"))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn value(cu_price: u64, tip: f64) -> GasFeeStrategyValue {
+        GasFeeStrategyValue { cu_limit: 100_000, cu_price, tip }
+    }
+
+    #[test]
+    fn select_task_configs_keeps_two_fee_lanes_per_swqos() {
+        let swqos_types = [SwqosType::Jito, SwqosType::Helius];
+        let configs = [
+            (SwqosType::Jito, GasFeeStrategyType::LowTipHighCuPrice, value(400_000, 0.002)),
+            (SwqosType::Jito, GasFeeStrategyType::HighTipLowCuPrice, value(180_000, 0.005)),
+            (SwqosType::Helius, GasFeeStrategyType::LowTipHighCuPrice, value(400_000, 0.002)),
+            (SwqosType::Helius, GasFeeStrategyType::HighTipLowCuPrice, value(180_000, 0.005)),
+        ];
+
+        let selected = select_swqos_task_configs(&swqos_types, &configs, true, false, |_| 0.0);
+
+        assert_eq!(selected.len(), 4);
+        assert_eq!(
+            selected.iter().filter(|task| task.gas_fee_config.0 == SwqosType::Jito).count(),
+            2
+        );
+        assert_eq!(
+            selected.iter().filter(|task| task.gas_fee_config.0 == SwqosType::Helius).count(),
+            2
+        );
+        assert_eq!(
+            selected.iter().map(|task| task.task_ordinal).collect::<Vec<_>>(),
+            vec![0, 1, 2, 3]
+        );
+        assert_eq!(
+            selected.iter().map(|task| task.swqos_index).collect::<Vec<_>>(),
+            vec![0, 0, 1, 1]
+        );
+    }
+
+    #[test]
+    fn select_task_configs_applies_min_tip_per_lane() {
+        let swqos_types = [SwqosType::Jito];
+        let configs = [
+            (SwqosType::Jito, GasFeeStrategyType::LowTipHighCuPrice, value(400_000, 0.0001)),
+            (SwqosType::Jito, GasFeeStrategyType::HighTipLowCuPrice, value(180_000, 0.005)),
+        ];
+
+        let selected = select_swqos_task_configs(&swqos_types, &configs, true, true, |_| 0.001);
+
+        assert_eq!(selected.len(), 1);
+        assert_eq!(selected[0].gas_fee_config.1, GasFeeStrategyType::HighTipLowCuPrice);
+    }
+
+    #[test]
+    fn select_task_configs_without_tip_keeps_default_priority_fee_only() {
+        let swqos_types = [SwqosType::Jito, SwqosType::Default];
+        let configs = [
+            (SwqosType::Jito, GasFeeStrategyType::LowTipHighCuPrice, value(400_000, 0.002)),
+            (SwqosType::Default, GasFeeStrategyType::Normal, value(700_000, 0.0)),
+        ];
+
+        let selected = select_swqos_task_configs(&swqos_types, &configs, false, false, |_| 0.0);
+
+        assert_eq!(selected.len(), 1);
+        assert_eq!(selected[0].gas_fee_config.0, SwqosType::Default);
+        assert_eq!(selected[0].gas_fee_config.2.cu_price, 700_000);
+        assert_eq!(selected[0].gas_fee_config.2.tip, 0.0);
+    }
+}

src/trading/core/executor.rs

@@ -12,10 +12,9 @@ use std::{
 use tracing::{info, trace, warn};
 
 use super::{params::SwapParams, traits::InstructionBuilder};
-use crate::swqos::SwqosType;
 use crate::swqos::TradeType;
 use crate::{
-    common::{nonce_cache::DurableNonceInfo, GasFeeStrategy, SolanaRpcClient},
+    common::{nonce_cache::DurableNonceInfo, GasFeeStrategy, SolanaRpcClient, SwqosSubmitTiming},
     perf::syscall_bypass::SystemCallBypassManager,
     swqos::common::poll_any_transaction_confirmation,
     trading::core::{
@@ -56,7 +55,7 @@ impl TradeExecutor for GenericTradeExecutor {
     async fn swap(
         &self,
         params: SwapParams,
-    ) -> Result<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<(SwqosType, i64)>)> {
+    ) -> Result<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<SwqosSubmitTiming>)> {
         // Sample total start only when logging or simulate. 仅在有日志或 simulate 时取起点。
         let total_start = (params.log_enabled || params.simulate).then(Instant::now);
         let timing_start_us: Option<i64> = if params.log_enabled {
@@ -187,7 +186,7 @@ impl TradeExecutor for GenericTradeExecutor {
             Err(e) => (false, vec![], Some(anyhow::anyhow!("{}", e)), vec![]),
         };
         // submit_timings 为完成先后顺序（先完成的先 push），打印不排序、不增加延迟
-        let submit_timings_ref: &[(crate::swqos::SwqosType, i64)] = submit_timings.as_slice();
+        let submit_timings_ref: &[SwqosSubmitTiming] = submit_timings.as_slice();
 
         let result = if need_confirm {
             let confirm_result = if let Some(rpc) = params.rpc.as_ref() {
@@ -257,7 +256,7 @@ async fn simulate_transaction(
     is_buy: bool,
     with_tip: bool,
     gas_fee_strategy: GasFeeStrategy,
-) -> Result<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<(SwqosType, i64)>)> {
+) -> Result<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<SwqosSubmitTiming>)> {
     use crate::trading::common::build_transaction;
     use solana_client::rpc_config::RpcSimulateTransactionConfig;
     use solana_commitment_config::CommitmentLevel;
@@ -351,6 +350,7 @@ async fn simulate_transaction(
 
 #[cfg(test)]
 mod tests {
+    use crate::common::GasFeeStrategyType;
     use crate::swqos::SwqosType;
 
     /// 运行 `cargo test -p sol-trade-sdk log_timing_preview -- --nocapture` 查看日志打印效果
@@ -377,15 +377,17 @@ mod tests {
         );
 
         println!("\n--- 2. 每个 SWQOS 独立耗时：submit_done=起点→该通道提交完成, confirmed=该通道提交→链上确认, total=起点→链上确认 ---\n");
-        for (swqos_type, submit_ms, confirmed_ms, total_ms) in [
-            (SwqosType::Jito, 45.12, 83.38, 128.50),
-            (SwqosType::Helius, 52.30, 76.20, 128.50),
-            (SwqosType::ZeroSlot, 48.90, 79.60, 128.50),
+        for (swqos_type, strategy_type, submit_ms, confirmed_ms, total_ms) in [
+            (SwqosType::Jito, GasFeeStrategyType::LowTipHighCuPrice, 45.12, 83.38, 128.50),
+            (SwqosType::Jito, GasFeeStrategyType::HighTipLowCuPrice, 46.08, 82.42, 128.50),
+            (SwqosType::Helius, GasFeeStrategyType::LowTipHighCuPrice, 52.30, 76.20, 128.50),
+            (SwqosType::ZeroSlot, GasFeeStrategyType::Normal, 48.90, 79.60, 128.50),
         ] {
             println!(
-                " [SDK][{:width$}] {} submit_done: {:.4} ms, confirmed: {:.4} ms, total: {:.4} ms",
+                " [SDK][{:width$}] {} {} submit_done: {:.4} ms, confirmed: {:.4} ms, total: {:.4} ms",
                 swqos_type.as_str(),
                 dir,
+                strategy_type.as_str(),
                 submit_ms,
                 confirmed_ms,
                 total_ms,
@@ -396,13 +398,16 @@ mod tests {
         println!(
             "\n--- 3. 不等待链上确认时：每行 total = 该通道 submit_done（提交完成总耗时）---\n"
         );
-        for (swqos_type, submit_ms, total_ms) in
-            [(SwqosType::Jito, 44.20, 44.20), (SwqosType::Helius, 51.80, 51.80)]
-        {
+        for (swqos_type, strategy_type, submit_ms, total_ms) in [
+            (SwqosType::Jito, GasFeeStrategyType::LowTipHighCuPrice, 44.20, 44.20),
+            (SwqosType::Jito, GasFeeStrategyType::HighTipLowCuPrice, 45.10, 45.10),
+            (SwqosType::Helius, GasFeeStrategyType::Normal, 51.80, 51.80),
+        ] {
             println!(
-                " [SDK][{:width$}] {} submit_done: {:.4} ms, confirmed: -, total: {:.4} ms",
+                " [SDK][{:width$}] {} {} submit_done: {:.4} ms, confirmed: -, total: {:.4} ms",
                 swqos_type.as_str(),
                 dir,
+                strategy_type.as_str(),
                 submit_ms,
                 total_ms,
                 width = w

src/trading/core/params/dex_swap.rs

@@ -94,14 +94,11 @@ pub struct SwapParams {
     pub check_min_tip: bool,
     /// Optional event receive time in microseconds (same scale as sol-parser-sdk clock::now_micros). Used as timing start when log_enabled.
     pub grpc_recv_us: Option<i64>,
-    /// Use exact SOL amount instructions (buy_exact_sol_in for PumpFun, buy_exact_quote_in for PumpSwap).
+    /// Use exact quote-input buy instructions (legacy PumpFun uses SOL quote; V2/PumpSwap use generic quote).
     /// When Some(true) or None (default), the exact SOL/quote amount is spent and slippage is applied to output tokens.
     /// When Some(false), uses regular buy instruction where slippage is applied to SOL/quote input.
     /// This option only applies to PumpFun and PumpSwap DEXes; it is ignored for other DEXes.
     pub use_exact_sol_amount: Option<bool>,
-    /// Use PumpFun V2 instructions (buy_v2 / sell_v2 / buy_exact_quote_in_v2, 27/26-account metas, quote_mint support).
-    /// Default: `false` keeps legacy SOL-paired instructions for smaller transactions; V2 is the official future-proof interface.
-    pub use_pumpfun_v2: bool,
 }
 
 impl SwapParams {

src/trading/core/params/pumpfun.rs

@@ -14,9 +14,9 @@ use std::sync::Arc;
 /// **Buy/sell**：`creator_vault` 及（若可得）**`tradeEvent` / CPI 日志中的 `creator`** 优先于陈旧的曲线快照；
 /// ix 组装与链下询价见 [`Self::effective_creator_for_trade`]、[`crate::instruction::utils::pumpfun::resolve_creator_vault_for_ix_with_fee_sharing`]。
 ///
-/// **V2 instructions**: Set `use_v2_ix = true` to use `buy_v2`/`sell_v2`/`buy_exact_quote_in_v2`
-/// with unified 27/26-account layout. Required for USDC-paired coins (`quote_mint != WSOL`).
-/// For SOL-paired coins, legacy instructions still work and are the default.
+/// **V2 instructions**: The SDK selects the layout automatically from `quote_mint`.
+/// Leave `quote_mint` default, or pass the Solscan SOL sentinel (`SOL_TOKEN_ACCOUNT`), for
+/// legacy SOL layout. Pass `WSOL_TOKEN_ACCOUNT` for SOL V2, or USDC for USDC-paired coins.
 #[derive(Clone)]
 pub struct PumpFunParams {
     pub bonding_curve: Arc<BondingCurveAccount>,
@@ -32,22 +32,30 @@ pub struct PumpFunParams {
     /// `Some(PDA(["creator-vault", fee_sharing_config]))` when pump-fees `SharingConfig` is **Active**; set by `from_mint_by_rpc` / [`refresh_fee_sharing_creator_vault_from_rpc`](Self::refresh_fee_sharing_creator_vault_from_rpc).
     pub fee_sharing_creator_vault_if_active: Option<Pubkey>,
     /// SPL Token or Token-2022 program id owning the **mint** (from gRPC / parser / cache).
-    /// **`Pubkey::default()`**：ix 构建时使用 SDK 默认 **Token-2022**（与多数 Pump.fun 新发一致）；显式传入 Legacy 或 Token-2022 id 可覆盖该默认值。
+    /// **`Pubkey::default()`**：ix 构建时使用 SDK 默认 **Token-2022**（与多数 Pump.fun 新发一致）。
+    /// 显式传入 Legacy 或 Token-2022 id 时严格按该值组装，不再用 mint 字符串后缀猜测。
     pub token_program: Pubkey,
     /// Whether to close token account when selling, only effective during sell operations
     pub close_token_account_when_sell: Option<bool>,
     /// Fee recipient for buy/sell account #2. Set from sol-parser-sdk (`tradeEvent.feeRecipient` / 同笔 create_v2+buy 回填的 `observed_fee_recipient`)；热路径不查 RPC。
-    /// `Pubkey::default()` 时按 mayhem 从静态池随机（与 npm 静态池一致，可能落后于主网 Global）。
+    /// `Pubkey::default()` 时只能使用 SDK 静态 fallback，可能落后于主网 Global；交易热路径应优先传入 gRPC / parser 观测值。
     pub fee_recipient: Pubkey,
-    /// Quote mint for v2 instructions (default: `So11111111111111111111111111111111111111112` for SOL-paired).
+    /// Quote mint layout selector. Default and `SOL_TOKEN_ACCOUNT` use legacy SOL layout.
+    /// `WSOL_TOKEN_ACCOUNT` selects SOL v2; USDC selects USDC v2.
     /// For USDC-paired coins, set to `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`.
     pub quote_mint: Pubkey,
-    /// Whether to use v2 instructions (`buy_v2`/`sell_v2`/`buy_exact_quote_in_v2`).
-    /// Default `false` for backward compatibility. Must be `true` for USDC-paired coins.
-    pub use_v2_ix: bool,
 }
 
 impl PumpFunParams {
+    #[inline]
+    fn quote_mint_for_layout(quote_mint: Pubkey) -> Pubkey {
+        if quote_mint == Pubkey::default() || quote_mint == crate::constants::SOL_TOKEN_ACCOUNT {
+            Pubkey::default()
+        } else {
+            BondingCurveAccount::normalize_quote_mint(quote_mint)
+        }
+    }
+
     pub fn immediate_sell(
         creator_vault: Pubkey,
         token_program: Pubkey,
@@ -63,12 +71,12 @@ impl PumpFunParams {
             close_token_account_when_sell: Some(close_token_account_when_sell),
             fee_recipient: Pubkey::default(),
             quote_mint: Pubkey::default(),
-            use_v2_ix: false,
         }
     }
 
-    /// When building from event/parser (e.g. sol-parser-sdk), pass `is_cashback_coin` from the event
-    /// so that sell instructions include the correct remaining accounts for cashback.
+    /// Build PumpFun params from a SOL-paired dev trade event. For USDC-paired dev trades,
+    /// use [`Self::from_dev_trade_with_quote_mint`] so reserve reconstruction uses the right quote mint.
+    /// Also pass `is_cashback_coin` from the event so sells include the correct remaining accounts.
     /// `mayhem_mode`: `Some` when known from Create/Trade event (`is_mayhem_mode` / `mayhem_mode`).
     /// `None` falls back to detecting Mayhem via reserved fee recipient pubkeys only (not AMM protocol fee accounts).
     pub fn from_dev_trade(
@@ -85,15 +93,51 @@ impl PumpFunParams {
         is_cashback_coin: bool,
         mayhem_mode: Option<bool>,
     ) -> Self {
-        let is_mayhem_mode = reconcile_mayhem_mode_for_trade(mayhem_mode, &fee_recipient);
-        let bonding_curve_account = BondingCurveAccount::from_dev_trade(
-            bonding_curve,
-            &mint,
+        Self::from_dev_trade_with_quote_mint(
+            mint,
             token_amount,
             max_sol_cost,
             creator,
+            bonding_curve,
+            associated_bonding_curve,
+            creator_vault,
+            close_token_account_when_sell,
+            fee_recipient,
+            token_program,
+            is_cashback_coin,
+            mayhem_mode,
+            Pubkey::default(),
+        )
+    }
+
+    /// Quote-aware constructor for PumpFun V2 pools. Use this for USDC-paired coins so
+    /// dev-trade reserve reconstruction uses the quote mint's initial virtual reserves.
+    pub fn from_dev_trade_with_quote_mint(
+        mint: Pubkey,
+        token_amount: u64,
+        max_quote_cost: u64,
+        creator: Pubkey,
+        bonding_curve: Pubkey,
+        associated_bonding_curve: Pubkey,
+        creator_vault: Pubkey,
+        close_token_account_when_sell: Option<bool>,
+        fee_recipient: Pubkey,
+        token_program: Pubkey,
+        is_cashback_coin: bool,
+        mayhem_mode: Option<bool>,
+        quote_mint: Pubkey,
+    ) -> Self {
+        let is_mayhem_mode = reconcile_mayhem_mode_for_trade(mayhem_mode, &fee_recipient);
+        let effective_quote_mint = BondingCurveAccount::normalize_quote_mint(quote_mint);
+        let bonding_curve_account = BondingCurveAccount::from_dev_trade_with_quote_mint(
+            bonding_curve,
+            &mint,
+            token_amount,
+            max_quote_cost,
+            creator,
             is_mayhem_mode,
             is_cashback_coin,
+            effective_quote_mint,
         );
         let creator_vault_resolved =
             crate::instruction::utils::pumpfun::resolve_creator_vault_for_ix_with_fee_sharing(
@@ -117,13 +161,14 @@ impl PumpFunParams {
             close_token_account_when_sell: close_token_account_when_sell,
             token_program: token_program,
             fee_recipient,
-            quote_mint: Pubkey::default(),
-            use_v2_ix: false,
+            quote_mint: Self::quote_mint_for_layout(quote_mint),
         }
     }
 
-    /// When building from event/parser (e.g. sol-parser-sdk), pass `is_cashback_coin` from the event
-    /// so that sell instructions include the correct remaining accounts for cashback.
+    /// Build PumpFun params from event/parser data. Pass `quote_mint` from the event:
+    /// `Pubkey::default()` / `SOL_TOKEN_ACCOUNT` for legacy SOL layout,
+    /// `WSOL_TOKEN_ACCOUNT` for SOL V2, and `USDC_TOKEN_ACCOUNT` for USDC V2.
+    /// Also pass `is_cashback_coin` from the event so sells include the correct remaining accounts.
     ///
     /// `mayhem_mode`:
     /// - **`Some(v)`**：优先采用 gRPC / `tradeEvent`，但与 **`fee_recipient` 所属池**（Mayhem vs 普通，见 pump-public-docs）不一致时，以 fee 地址为准纠偏，避免链上 `NotAuthorized`。
@@ -132,12 +177,13 @@ impl PumpFunParams {
         bonding_curve: Pubkey,
         associated_bonding_curve: Pubkey,
         mint: Pubkey,
+        quote_mint: Pubkey,
         creator: Pubkey,
         creator_vault: Pubkey,
         virtual_token_reserves: u64,
-        virtual_sol_reserves: u64,
+        virtual_quote_reserves: u64,
         real_token_reserves: u64,
-        real_sol_reserves: u64,
+        real_quote_reserves: u64,
         close_token_account_when_sell: Option<bool>,
         fee_recipient: Pubkey,
         token_program: Pubkey,
@@ -145,16 +191,18 @@ impl PumpFunParams {
         mayhem_mode: Option<bool>,
     ) -> Self {
         let is_mayhem_mode = reconcile_mayhem_mode_for_trade(mayhem_mode, &fee_recipient);
-        let bonding_curve = BondingCurveAccount::from_trade(
+        let effective_quote_mint = BondingCurveAccount::normalize_quote_mint(quote_mint);
+        let bonding_curve = BondingCurveAccount::from_trade_with_quote_mint(
             bonding_curve,
             mint,
             creator,
             virtual_token_reserves,
-            virtual_sol_reserves,
+            virtual_quote_reserves,
             real_token_reserves,
-            real_sol_reserves,
+            real_quote_reserves,
             is_mayhem_mode,
             is_cashback_coin,
+            effective_quote_mint,
         );
         let creator_vault_resolved =
             crate::instruction::utils::pumpfun::resolve_creator_vault_for_ix_with_fee_sharing(
@@ -176,11 +224,48 @@ impl PumpFunParams {
             close_token_account_when_sell: close_token_account_when_sell,
             token_program: token_program,
             fee_recipient,
-            quote_mint: Pubkey::default(),
-            use_v2_ix: false,
+            quote_mint: Self::quote_mint_for_layout(quote_mint),
         }
     }
 
+    /// Deprecated compatibility alias. Prefer [`Self::from_trade`] and pass `quote_mint` there.
+    #[deprecated(note = "use PumpFunParams::from_trade(..., quote_mint)")]
+    pub fn from_trade_with_quote_mint(
+        bonding_curve: Pubkey,
+        associated_bonding_curve: Pubkey,
+        mint: Pubkey,
+        creator: Pubkey,
+        creator_vault: Pubkey,
+        virtual_token_reserves: u64,
+        virtual_quote_reserves: u64,
+        real_token_reserves: u64,
+        real_quote_reserves: u64,
+        close_token_account_when_sell: Option<bool>,
+        fee_recipient: Pubkey,
+        token_program: Pubkey,
+        is_cashback_coin: bool,
+        mayhem_mode: Option<bool>,
+        quote_mint: Pubkey,
+    ) -> Self {
+        Self::from_trade(
+            bonding_curve,
+            associated_bonding_curve,
+            mint,
+            quote_mint,
+            creator,
+            creator_vault,
+            virtual_token_reserves,
+            virtual_quote_reserves,
+            real_token_reserves,
+            real_quote_reserves,
+            close_token_account_when_sell,
+            fee_recipient,
+            token_program,
+            is_cashback_coin,
+            mayhem_mode,
+        )
+    }
+
     /// 仅 RPC 读取曲线快照；[`Self::observed_trade_creator`] 为 `None`，便于 bot 缓存合并时用粘性的 trade 日志 creator 覆盖陈旧曲线推导。
     pub async fn from_mint_by_rpc(
         rpc: &SolanaRpcClient,
@@ -201,6 +286,7 @@ impl PumpFunParams {
             creator: account.0.creator,
             is_mayhem_mode: account.0.is_mayhem_mode,
             is_cashback_coin: account.0.is_cashback_coin,
+            quote_mint: account.0.quote_mint,
         };
         let associated_bonding_curve = get_associated_token_address_with_program_id(
             &bonding_curve.account,
@@ -223,6 +309,7 @@ impl PumpFunParams {
                 crate::instruction::utils::pumpfun::get_creator_vault_pda(&bonding_curve.creator)
             })
             .unwrap_or_default();
+        let quote_mint = bonding_curve.quote_mint;
         Ok(Self {
             bonding_curve: Arc::new(bonding_curve),
             associated_bonding_curve: associated_bonding_curve,
@@ -232,8 +319,7 @@ impl PumpFunParams {
             close_token_account_when_sell: None,
             token_program: mint_account.owner,
             fee_recipient: Pubkey::default(),
-            quote_mint: Pubkey::default(),
-            use_v2_ix: false,
+            quote_mint: Self::quote_mint_for_layout(quote_mint),
         })
     }
 
@@ -272,12 +358,15 @@ impl PumpFunParams {
         Ok(self)
     }
 
-    /// Sets `quote_mint` and enables v2 instructions. Required for USDC-paired coins.
-    /// For SOL-paired coins, pass `WSOL_TOKEN_ACCOUNT` or leave default.
+    /// Sets `quote_mint`. The instruction builder derives V1/V2 layout from this value.
+    /// For legacy SOL-paired coins, pass `SOL_TOKEN_ACCOUNT` or leave default.
+    /// Pass `WSOL_TOKEN_ACCOUNT` only when you intentionally want SOL v2 layout.
     #[inline]
     pub fn with_quote_mint(mut self, quote_mint: Pubkey) -> Self {
-        self.quote_mint = quote_mint;
-        self.use_v2_ix = quote_mint != Pubkey::default();
+        let effective_quote_mint = BondingCurveAccount::normalize_quote_mint(quote_mint);
+        self.quote_mint = Self::quote_mint_for_layout(quote_mint);
+        let curve = Arc::make_mut(&mut self.bonding_curve);
+        *curve = curve.clone().with_quote_mint(effective_quote_mint);
         self
     }
 

src/trading/core/traits.rs

@@ -1,4 +1,4 @@
-use crate::swqos::SwqosType;
+use crate::common::SwqosSubmitTiming;
 use crate::trading::SwapParams;
 use anyhow::Result;
 use solana_sdk::{instruction::Instruction, signature::Signature};
@@ -12,7 +12,7 @@ pub trait TradeExecutor: Send + Sync {
     async fn swap(
         &self,
         params: SwapParams,
-    ) -> Result<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<(SwqosType, i64)>)>;
+    ) -> Result<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<SwqosSubmitTiming>)>;
     /// 获取协议名称
     fn protocol_name(&self) -> &'static str;
 }

src/trading/core/transaction_pool.rs

@@ -17,6 +17,7 @@ const PARALLEL_SENDER_COUNT: usize = 18;
 /// 启动时预填充数量，必须 >= PARALLEL_SENDER_COUNT，否则 18 路并发 build 会触发分配或争抢
 const TX_BUILDER_POOL_PREFILL: usize = 64;
 
+use anyhow::Result;
 use crossbeam_queue::ArrayQueue;
 use once_cell::sync::Lazy;
 use solana_message::AddressLookupTableAccount;
@@ -82,7 +83,7 @@ impl PreallocatedTxBuilder {
         instructions: &[Instruction],
         address_lookup_table_account: Option<&AddressLookupTableAccount>,
         recent_blockhash: Hash,
-    ) -> VersionedMessage {
+    ) -> Result<VersionedMessage> {
         self.reset();
         self.instructions.extend_from_slice(instructions);
 
@@ -92,14 +93,13 @@ impl PreallocatedTxBuilder {
                 &self.instructions,
                 std::slice::from_ref(alt),
                 recent_blockhash,
-            )
-            .expect("v0 message compile failed");
-            VersionedMessage::V0(message)
+            )?;
+            Ok(VersionedMessage::V0(message))
         } else {
             // ✅ 没有查找表，使用 Legacy 消息（兼容所有 RPC）
             let message =
                 Message::new_with_blockhash(&self.instructions, Some(payer), &recent_blockhash);
-            VersionedMessage::Legacy(message)
+            Ok(VersionedMessage::Legacy(message))
         }
     }
 }

src/utils/calc/pumpfun.rs

@@ -1,22 +1,10 @@
-// Note: sol_to_lamports moved to solana_native_token crate in 3.x
-// Using manual conversion: 1 SOL = 1_000_000_000 lamports
 use solana_sdk::pubkey::Pubkey;
 
-fn sol_to_lamports(sol: f64) -> u64 {
-    (sol * 1_000_000_000.0) as u64
-}
-
 use crate::{
     instruction::utils::pumpfun::global_constants::{CREATOR_FEE, FEE_BASIS_POINTS},
     utils::calc::common::compute_fee,
 };
 
-/// Converts SOL string to lamports (wrapper for sol_to_lamports)
-#[inline]
-fn sol_str_to_lamports(sol: &str) -> Option<u64> {
-    sol.parse::<f64>().ok().map(|s| sol_to_lamports(s))
-}
-
 /// Calculates the amount of tokens that can be purchased with a given SOL amount
 /// using the bonding curve formula.
 ///
@@ -54,26 +42,21 @@ pub fn get_buy_token_amount_from_sol_amount(
 
     let input_amount = amount_128
         .checked_mul(10_000)
-        .unwrap()
-        .checked_div(total_fee_basis_points_128 + 10_000)
-        .unwrap();
+        .and_then(|v| v.checked_div(total_fee_basis_points_128 + 10_000))
+        .unwrap_or(0);
 
-    let denominator = virtual_sol_reserves + input_amount;
-
-    let mut tokens_received =
-        input_amount.checked_mul(virtual_token_reserves).unwrap().checked_div(denominator).unwrap();
-
-    tokens_received = tokens_received.min(real_token_reserves);
-
-    if tokens_received <= 100 * 1_000_000_u128 {
-        tokens_received = if amount > sol_str_to_lamports("0.01").unwrap_or(0) {
-            25547619 * 1_000_000_u128
-        } else {
-            255476 * 1_000_000_u128
-        };
+    let Some(denominator) = virtual_sol_reserves.checked_add(input_amount) else { return 0 };
+    if denominator == 0 {
+        return 0;
     }
 
-    tokens_received as u64
+    let tokens_received = input_amount
+        .checked_mul(virtual_token_reserves)
+        .and_then(|v| v.checked_div(denominator))
+        .unwrap_or(0)
+        .min(real_token_reserves);
+
+    tokens_received.min(u64::MAX as u128) as u64
 }
 
 /// Calculates the amount of SOL that will be received when selling a given token amount