fix(pumpswap): harden quotes and low-latency examples

feat(swqos): default Lunar Lander to QUIC

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sol-trade-sdk"
-version = "4.0.22"
+version = "5.0.0"
 edition = "2021"
 authors = [
     "William <byteblock6@gmail.com>",
@@ -75,6 +75,9 @@ futures = "0.3.31"
 futures-util = "0.3.31"
 base64 = "0.22.1"
 bs58 = "0.5.1"
+# `five8` 1.0 permits five8_core 0.1.x, whose DecodeError implements
+# std::error::Error only with this feature. Solana keypair decoding requires it.
+five8_core = { version = "0.1.2", features = ["std"] }
 rand = "0.9.0"
 bincode = "1.3.3"
 anyhow = "1.0.90"

README.md

@@ -92,9 +92,9 @@ This SDK is available in multiple languages:
 
 ## 🔖 Current Release
 
-**Rust crate:** `sol-trade-sdk = "4.0.21"`
+**Rust crate:** `sol-trade-sdk = "4.0.23"`
 
-This release refreshes PumpFun native-SOL quote handling so SOL/WSOL sentinels prefer the smaller V1 hot path, keeps the default RPC submit lane active alongside SWQoS lanes, restores the fast-submit result window to 5 seconds, and aligns Raydium CPMM fixed-output swaps with the on-chain `swap_base_out` instruction. Trade execution requires a caller-supplied `recent_blockhash` or durable nonce; hot-path execution does not query RPC for blockhash, account, or balance data.
+This release updates PumpSwap for the July 2026 virtual quote reserve rollout. Pool and event schemas include `virtual_quote_reserves`, and all PumpSwap buy, sell, pricing, and dynamic-fee calculations use `quote_vault_balance + virtual_quote_reserves`.
 
 ## ✨ Features
 
@@ -126,14 +126,14 @@ Add the dependency to your `Cargo.toml`:
 
 ```toml
 # Add to your Cargo.toml
-sol-trade-sdk = { path = "./sol-trade-sdk", version = "4.0.21" }
+sol-trade-sdk = { path = "./sol-trade-sdk", version = "4.0.23" }
 ```
 
 ### Use crates.io
 
 ```toml
 # Add to your Cargo.toml
-sol-trade-sdk = "4.0.21"
+sol-trade-sdk = "4.0.23"
 ```
 
 ## 🛠️ Usage Examples
@@ -506,6 +506,14 @@ For **PumpSwap** (Pump AMM), `coin_creator_vault_ata` and `coin_creator_vault_au
 - **sol-parser-sdk**: Instruction parser sets them from accounts 17 and 18; the account filler also fills them when the event comes from logs. Use `PumpSwapParams::from_trade(..., e.coin_creator_vault_ata, e.coin_creator_vault_authority, ...)` with the buy/sell event `e`.
 - **solana-streamer**: Instruction parser sets them from `accounts.get(17)` and `accounts.get(18)`. Use the same `from_trade` with the event's `coin_creator_vault_ata` and `coin_creator_vault_authority`.
 
+#### PumpSwap: virtual quote reserves
+
+PumpSwap quotes must use `effective_quote_reserves = pool_quote_token_account.amount + virtual_quote_reserves`. The Pool account and BuyEvent/SellEvent encode `virtual_quote_reserves` as `i128`.
+
+- RPC constructors such as `PumpSwapParams::from_pool_address_by_rpc` read and apply the Pool field automatically.
+- Event fast paths must pass the event's raw `pool_quote_token_reserves` and `virtual_quote_reserves` separately to `PumpSwapParams::from_trade(...)` or `from_trade_with_fee_basis_points(...)`. Do not add them before calling the constructor.
+- The SDK uses effective reserves for buys, sells, prices, and dynamic fee-tier selection. Invalid signed sums return an error instead of wrapping.
+
 ## 🛡️ MEV Protection Services
 
 You can apply for a key through the official website: [Community Website](https://fnzero.dev/swqos)

README_CN.md

@@ -92,9 +92,9 @@
 
 ## 🔖 当前版本
 
-**Rust crate:** `sol-trade-sdk = "4.0.21"`
+**Rust crate:** `sol-trade-sdk = "4.0.23"`
 
-本版本刷新 PumpFun native SOL quote 处理逻辑，SOL/WSOL sentinel 默认优先走更小的 V1 热路径，确保默认 RPC 提交通道会和 SWQoS 通道一起发出，快速提交结果等待窗口恢复为 5 秒，并将 Raydium CPMM fixed-output 交易对齐到链上 `swap_base_out` 指令。交易执行必须由调用方传入 `recent_blockhash` 或 durable nonce；热路径不会查询 RPC 获取 blockhash、账户或余额数据。
+本版本适配 PumpSwap 2026 年 7 月的虚拟 quote 储备升级。Pool 与事件 schema 新增 `virtual_quote_reserves`，PumpSwap 买入、卖出、报价和动态费率计算统一使用 `quote_vault_balance + virtual_quote_reserves`。
 
 ## ✨ 项目特性
 
@@ -126,14 +126,14 @@ git clone https://github.com/0xfnzero/sol-trade-sdk
 
 ```toml
 # 添加到您的 Cargo.toml
-sol-trade-sdk = { path = "./sol-trade-sdk", version = "4.0.21" }
+sol-trade-sdk = { path = "./sol-trade-sdk", version = "4.0.23" }
 ```
 
 ### 使用 crates.io
 
 ```toml
 # 添加到您的 Cargo.toml
-sol-trade-sdk = "4.0.21"
+sol-trade-sdk = "4.0.23"
 ```
 
 ## 🛠️ 使用示例
@@ -503,6 +503,14 @@ legacy SOL 事件里如果 `quote_mint` 是默认值或 Solscan SOL，并且 quo
 | 未设置（默认）/ `SOL_TOKEN_ACCOUNT` (`So111...11111`) / `WSOL_TOKEN_ACCOUNT` (`So111...11112`) | 优先旧版 `buy`/`sell`/`buy_exact_sol_in` | native SOL 配对；普通 SOL 结算走 V1，显式 WSOL 结算才走 V2 |
 | `USDC_TOKEN_ACCOUNT` | `buy_v2`/`sell_v2`/`buy_exact_quote_in_v2` | USDC 配对（必须使用 v2） |
 
+#### PumpSwap：虚拟 quote 储备
+
+PumpSwap 报价必须使用 `effective_quote_reserves = pool_quote_token_account.amount + virtual_quote_reserves`。Pool 账户以及 BuyEvent/SellEvent 中的 `virtual_quote_reserves` 类型均为 `i128`。
+
+- `PumpSwapParams::from_pool_address_by_rpc` 等 RPC 构造器会自动读取并应用 Pool 字段。
+- 事件热路径必须把事件中的原始 `pool_quote_token_reserves` 和 `virtual_quote_reserves` 分别传给 `PumpSwapParams::from_trade(...)` 或 `from_trade_with_fee_basis_points(...)`，不要在调用前自行相加。
+- SDK 在买入、卖出、报价和动态费率分层中统一使用有效储备；无效的有符号结果会返回错误，不会发生整数回绕。
+
 ## 🛡️ MEV 保护服务
 
 可以通过官网申请密钥：[社区官网](https://fnzero.dev/swqos)

docs/LOW_LATENCY_BOTS.md

@@ -20,10 +20,12 @@ Do not initialize clients, synchronously fetch a blockhash, query balances, or s
 | Sell an exact token amount | `SellAmount::ExactInput` |
 
 `WithMaxInput` still enforces slippage. Never use `min_out = 0` as routine error handling.
+Exact-output support is protocol- and pool-direction-specific. PumpSwap exposes exact output through its on-chain `buy` instruction, but its `sell` instruction accepts exact base input plus minimum quote output; the SDK rejects `SellAmount::ExactOutput` when that direction would require `sell`.
 
 Use post-trade event reserves. Preserve PumpFun quote mint, creator/vault, token program, cashback, and mayhem fields. PumpSwap event integrations should use `from_trade_with_fee_basis_points`. Refresh delayed sells because the triggering trade and your own buy both change pool state. Durable nonce extends transaction validity, not quote validity.
 
 For `BuySlippageBelowMinBaseAmountOut`, discard the old transaction, obtain newer reserves and fee rates, enforce a quote-age limit, and rebuild only within a bounded retry policy.
+After a submit timeout or ambiguous relay error, reconcile the signature and position before retrying. A retry policy may rebuild quotes automatically only when the previous transaction is known not to have been submitted.
 
 Reference examples:
 

examples/address_lookup/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-sol-parser-sdk = "0.4.14"
+sol-parser-sdk = { version = "0.6.0", git = "https://github.com/0xfnzero/sol-parser-sdk", rev = "995d88991b56234a23fc1d0911fdd33caa063c67" }
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/bonk_copy_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-solana-streamer-sdk = "0.5.0"
+solana-streamer-sdk = { version = "2.0.0", git = "https://github.com/0xfnzero/solana-streamer", rev = "f1c6aecb3d4a4ebb2cd3c9f6a58de20b019418e2" }
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/bonk_copy_trading/src/main.rs

@@ -15,13 +15,12 @@ use sol_trade_sdk::{
     SolanaTrade,
 };
 use solana_commitment_config::CommitmentConfig;
-use solana_streamer_sdk::match_event;
 use solana_streamer_sdk::streaming::event_parser::common::filter::EventTypeFilter;
 use solana_streamer_sdk::streaming::event_parser::common::EventType;
 use solana_streamer_sdk::streaming::event_parser::protocols::bonk::parser::BONK_PROGRAM_ID;
 use solana_streamer_sdk::streaming::event_parser::protocols::bonk::BonkTradeEvent;
-use solana_streamer_sdk::streaming::event_parser::{Protocol, UnifiedEvent};
-use solana_streamer_sdk::streaming::yellowstone_grpc::{AccountFilter, TransactionFilter};
+use solana_streamer_sdk::streaming::event_parser::{DexEvent, Protocol};
+use solana_streamer_sdk::streaming::yellowstone_grpc::TransactionFilter;
 use solana_streamer_sdk::streaming::YellowstoneGrpc;
 
 // Global static flag to ensure transaction is executed only once
@@ -52,24 +51,19 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         account_required,
     };
 
-    // Listen to account data belonging to owner programs -> account event monitoring
-    let account_filter = AccountFilter { account: vec![], owner: vec![], filters: vec![] };
-
     // listen to specific event type
-    let event_type_filter = EventTypeFilter {
-        include: vec![
-            EventType::BonkBuyExactIn,
-            EventType::BonkSellExactIn,
-            EventType::BonkBuyExactOut,
-            EventType::BonkSellExactOut,
-        ],
-    };
+    let event_type_filter = EventTypeFilter::include_only(vec![
+        EventType::BonkBuyExactIn,
+        EventType::BonkSellExactIn,
+        EventType::BonkBuyExactOut,
+        EventType::BonkSellExactOut,
+    ]);
 
     grpc.subscribe_events_immediate(
         protocols,
         None,
         vec![transaction_filter],
-        vec![account_filter],
+        vec![],
         Some(event_type_filter),
         None,
         callback,
@@ -77,27 +71,25 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     .await?;
 
     tokio::signal::ctrl_c().await?;
+    grpc.stop().await;
 
     Ok(())
 }
 
 /// Create an event callback function that handles different types of events
-fn create_event_callback() -> impl Fn(Box<dyn UnifiedEvent>) {
-    |event: Box<dyn UnifiedEvent>| {
-        match_event!(event, {
-            BonkTradeEvent => |e: BonkTradeEvent| {
-                // Test code, only test one transaction
-                if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
-                    let event_clone = e.clone();
-                    tokio::spawn(async move {
-                        if let Err(err) = bonk_copy_trade_with_grpc(event_clone).await {
-                            eprintln!("Error in copy trade: {:?}", err);
-                            std::process::exit(1);
-                        }
-                    });
+fn create_event_callback() -> impl Fn(DexEvent) {
+    |event: DexEvent| {
+        let DexEvent::BonkTradeEvent(event) = event else {
+            return;
+        };
+        if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
+            tokio::spawn(async move {
+                if let Err(err) = bonk_copy_trade_with_grpc(event).await {
+                    eprintln!("Error in copy trade: {:?}", err);
+                    std::process::exit(1);
                 }
-            },
-        });
+            });
+        }
     }
 }
 

examples/bonk_sniper_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-solana-streamer-sdk = "0.5.0"
+solana-streamer-sdk = { version = "2.0.0", git = "https://github.com/0xfnzero/solana-streamer", rev = "f1c6aecb3d4a4ebb2cd3c9f6a58de20b019418e2" }
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/bonk_sniper_trading/src/main.rs

@@ -12,8 +12,8 @@ use solana_commitment_config::CommitmentConfig;
 use solana_streamer_sdk::streaming::event_parser::common::filter::EventTypeFilter;
 use solana_streamer_sdk::streaming::event_parser::common::EventType;
 use solana_streamer_sdk::streaming::event_parser::protocols::bonk::BonkTradeEvent;
-use solana_streamer_sdk::streaming::event_parser::{Protocol, UnifiedEvent};
-use solana_streamer_sdk::{match_event, streaming::ShredStreamGrpc};
+use solana_streamer_sdk::streaming::event_parser::{DexEvent, Protocol};
+use solana_streamer_sdk::streaming::ShredStreamGrpc;
 use std::sync::{
     atomic::{AtomicBool, Ordering},
     Arc,
@@ -29,16 +29,14 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let shred_stream = ShredStreamGrpc::new("use_your_shred_stream_url_here".to_string()).await?;
     let callback = create_event_callback();
     let protocols = vec![Protocol::Bonk];
-    let event_type_filter = EventTypeFilter {
-        include: vec![
-            EventType::BonkBuyExactIn,
-            EventType::BonkBuyExactOut,
-            EventType::BonkSellExactIn,
-            EventType::BonkSellExactOut,
-            EventType::BonkInitialize,
-            EventType::BonkInitializeV2,
-        ],
-    };
+    let event_type_filter = EventTypeFilter::include_only(vec![
+        EventType::BonkBuyExactIn,
+        EventType::BonkBuyExactOut,
+        EventType::BonkSellExactIn,
+        EventType::BonkSellExactOut,
+        EventType::BonkInitialize,
+        EventType::BonkInitializeV2,
+    ]);
     println!("Starting to listen for events, press Ctrl+C to stop...");
     shred_stream.shredstream_subscribe(protocols, None, Some(event_type_filter), callback).await?;
     tokio::signal::ctrl_c().await?;
@@ -46,27 +44,22 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 }
 
 /// Create an event callback function that handles different types of events
-fn create_event_callback() -> impl Fn(Box<dyn UnifiedEvent>) {
-    |event: Box<dyn UnifiedEvent>| {
-        match_event!(event, {
-            BonkTradeEvent => |e: BonkTradeEvent| {
-                // Only process developer token creation events
-                if !e.is_dev_create_token_trade {
-                    return;
+fn create_event_callback() -> impl Fn(DexEvent) {
+    |event: DexEvent| {
+        let DexEvent::BonkTradeEvent(event) = event else {
+            return;
+        };
+        if !event.is_dev_create_token_trade {
+            return;
+        }
+        if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
+            tokio::spawn(async move {
+                if let Err(err) = bonk_sniper_trade_with_shreds(event).await {
+                    eprintln!("Error in sniper trade: {:?}", err);
+                    std::process::exit(1);
                 }
-                // Ensure we only execute the trade once using atomic compare-and-swap
-                if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
-                    let event_clone = e.clone();
-                    // Spawn a new task to handle the trading operation
-                    tokio::spawn(async move {
-                        if let Err(err) = bonk_sniper_trade_with_shreds(event_clone).await {
-                            eprintln!("Error in sniper trade: {:?}", err);
-                            std::process::exit(1);
-                        }
-                    });
-                }
-            },
-        });
+            });
+        }
     }
 }
 

examples/meteora_damm_v2_direct_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-solana-streamer-sdk = "0.5.0"
+solana-streamer-sdk = { version = "2.0.0", git = "https://github.com/0xfnzero/solana-streamer", rev = "f1c6aecb3d4a4ebb2cd3c9f6a58de20b019418e2" }
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/middleware_system/Cargo.toml

@@ -5,8 +5,8 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-solana-streamer-sdk = "0.5.0"
+solana-streamer-sdk = { version = "2.0.0", git = "https://github.com/0xfnzero/solana-streamer", rev = "f1c6aecb3d4a4ebb2cd3c9f6a58de20b019418e2" }
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }
-anyhow = "1.0.79"
+anyhow = "1.0.79"

examples/nonce_cache/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-sol-parser-sdk = "0.4.14"
+sol-parser-sdk = { version = "0.6.0", git = "https://github.com/0xfnzero/sol-parser-sdk", rev = "995d88991b56234a23fc1d0911fdd33caa063c67" }
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 spl-associated-token-account = "7.0.0"

examples/pumpfun_copy_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-sol-parser-sdk = "0.4.14"
+sol-parser-sdk = { version = "0.6.0", git = "https://github.com/0xfnzero/sol-parser-sdk", rev = "995d88991b56234a23fc1d0911fdd33caa063c67" }
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/pumpfun_sniper_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-sol-parser-sdk = "0.4.14"
+sol-parser-sdk = { version = "0.6.0", git = "https://github.com/0xfnzero/sol-parser-sdk", rev = "995d88991b56234a23fc1d0911fdd33caa063c67" }
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/pumpswap_direct_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-solana-streamer-sdk = "0.5.0"
+solana-streamer-sdk = { version = "2.0.0", git = "https://github.com/0xfnzero/solana-streamer", rev = "f1c6aecb3d4a4ebb2cd3c9f6a58de20b019418e2" }
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/pumpswap_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-solana-streamer-sdk = "0.5.0"
+solana-streamer-sdk = { version = "2.0.0", git = "https://github.com/0xfnzero/solana-streamer", rev = "f1c6aecb3d4a4ebb2cd3c9f6a58de20b019418e2" }
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/pumpswap_trading/README.md

@@ -21,7 +21,9 @@ cargo run --release --package pumpswap_trading
 
 - The buy uses `BuyAmount::WithMaxInput`, which applies slippage to maximum quote cost and is appropriate when fill priority matters.
 - Buy parameters use post-trade reserves and LP/protocol/creator fee bps from the event.
-- The example records the pre-buy balance and sells only the confirmed balance increase. It refreshes pool state and blockhash before selling.
+- The event's raw and virtual quote reserves come from the same transaction snapshot. The hot path does not fetch the Pool account, avoiding both added latency and mixed-slot quotes.
+- The first matching event asynchronously records the pre-buy balance; the next fresh event performs the trade without a balance RPC in the submission hot path. It sells only the confirmed balance increase and refreshes pool state and blockhash before selling.
 - Use `BuyAmount::ExactInput` when the quote spend must be exact. That mode protects minimum output and can fail more often in an active pool.
+- If baseline warmup fails, the example waits for another event. Once transaction execution starts, an error keeps the one-shot guard locked because submission or position state may be uncertain; inspect the signatures and account state before retrying.
 
 Production bots should also add durable signature deduplication, a position state machine, SWQoS configuration, and bounded requoting. Do not solve slippage errors by setting `min_out` to zero.

examples/pumpswap_trading/README_CN.md

@@ -19,7 +19,9 @@ cargo run --release --package pumpswap_trading
 
 - 买入使用 `BuyAmount::WithMaxInput`，适合优先成交的跟单/狙击场景，滑点限制最大 quote 成本。
 - 买入参数使用事件中的成交后储备和 LP/protocol/creator fee bps。
-- 示例记录买前余额，只卖出确认后的余额增量；卖出前重新获取池状态和 blockhash。
+- 原始 quote 储备和虚拟 quote 储备均来自同一笔交易的事件快照；热路径不再查询 Pool 账户，避免额外延迟和跨 slot 混合报价。
+- 第一个匹配事件用于异步记录买前余额，下一条新鲜事件才会交易，因此提交热路径不再查询余额；示例只卖出确认后的余额增量，并在卖出前重新获取池状态和 blockhash。
 - 若业务必须精确花费 quote，应改用 `BuyAmount::ExactInput`。这会启用最小输出保护，在活跃池中更容易因状态变化而失败。
+- 基线预热失败时会等待后续事件；一旦进入交易阶段，错误会保持单次执行锁定，因为提交状态或持仓可能不确定，必须先核对签名和账户状态再重试。
 
 生产机器人还应增加持久化签名去重、持仓状态机、SWQoS 配置和有限次数的重新报价。不要通过把 `min_out` 设为零来处理滑点错误。

examples/pumpswap_trading/src/main.rs

@@ -11,22 +11,20 @@ use sol_trade_sdk::{
 };
 use solana_commitment_config::CommitmentConfig;
 use solana_sdk::{hash::Hash, pubkey::Pubkey};
+use solana_streamer_sdk::streaming::event_parser::protocols::pumpswap::parser::PUMPSWAP_PROGRAM_ID;
 use solana_streamer_sdk::streaming::event_parser::{
     common::filter::EventTypeFilter, protocols::pumpswap::PumpSwapBuyEvent,
 };
 use solana_streamer_sdk::streaming::event_parser::{
     common::EventType, protocols::pumpswap::PumpSwapSellEvent,
 };
-use solana_streamer_sdk::streaming::event_parser::{Protocol, UnifiedEvent};
+use solana_streamer_sdk::streaming::event_parser::{DexEvent, Protocol};
 use solana_streamer_sdk::streaming::yellowstone_grpc::{AccountFilter, TransactionFilter};
 use solana_streamer_sdk::streaming::YellowstoneGrpc;
-use solana_streamer_sdk::{
-    match_event, streaming::event_parser::protocols::pumpswap::parser::PUMPSWAP_PROGRAM_ID,
-};
 use std::str::FromStr;
 use std::sync::{
     atomic::{AtomicBool, Ordering},
-    Arc,
+    Arc, RwLock,
 };
 use std::time::{Duration, Instant};
 use tokio::sync::watch;
@@ -93,6 +91,18 @@ struct CachedBlockhash {
     fetched_at: Instant,
 }
 
+#[derive(Clone, Copy)]
+struct PositionBaseline {
+    mint: Pubkey,
+    token_program: Pubkey,
+    amount: u64,
+}
+
+enum EventAction {
+    BaselineWarmed,
+    TradeCompleted,
+}
+
 #[derive(Clone)]
 struct BlockhashCache {
     receiver: watch::Receiver<CachedBlockhash>,
@@ -141,6 +151,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let trade_client = Arc::new(create_solana_trade_client().await?);
     let blockhash_cache = BlockhashCache::start(trade_client.infrastructure.rpc.clone()).await?;
+    let position_baseline = Arc::new(RwLock::new(None));
 
     let grpc = YellowstoneGrpc::new(
         std::env::var("GRPC_ENDPOINT")
@@ -148,7 +159,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         std::env::var("GRPC_AUTH_TOKEN").ok(),
     )?;
 
-    let callback = create_event_callback(trade_client, blockhash_cache, selection);
+    let callback =
+        create_event_callback(trade_client, blockhash_cache, position_baseline, selection);
     let protocols = vec![Protocol::PumpSwap];
     // Filter accounts
     let account_include = vec![
@@ -169,8 +181,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let account_filter = AccountFilter { account: vec![], owner: vec![], filters: vec![] };
 
     // listen to specific event type
-    let event_type_filter =
-        EventTypeFilter { include: vec![EventType::PumpSwapBuy, EventType::PumpSwapSell] };
+    let event_type_filter = EventTypeFilter {
+        include: vec![EventType::PumpSwapBuy, EventType::PumpSwapSell],
+        ..Default::default()
+    };
 
     grpc.subscribe_events_immediate(
         protocols,
@@ -192,63 +206,107 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 fn create_event_callback(
     client: Arc<SolanaTrade>,
     blockhash_cache: BlockhashCache,
+    position_baseline: Arc<RwLock<Option<PositionBaseline>>>,
     selection: EventSelection,
-) -> impl Fn(Box<dyn UnifiedEvent>) {
-    move |event: Box<dyn UnifiedEvent>| {
-        match_event!(event, {
-            PumpSwapBuyEvent => |e: PumpSwapBuyEvent| {
-                let is_wsol = e.base_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT || e.quote_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT;
-                let is_usdc = e.base_mint == sol_trade_sdk::constants::USDC_TOKEN_ACCOUNT || e.quote_mint == sol_trade_sdk::constants::USDC_TOKEN_ACCOUNT;
-                if !is_wsol && !is_usdc {
-                    return;
-                }
-                if !selection.matches(e.pool, e.base_mint, e.quote_mint, e.metadata.recv_us) {
-                    return;
-                }
-                // Test code, only test one transaction
-                if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
-                    let event_clone = e.clone();
-                    let client = client.clone();
-                    let blockhash_cache = blockhash_cache.clone();
-                    tokio::spawn(async move {
-                        if let Err(err) = pumpswap_trade_with_grpc_buy_event(
-                            client,
-                            blockhash_cache,
-                            event_clone,
-                        ).await {
-                            eprintln!("Error in trade: {:?}", err);
-                            std::process::exit(1);
-                        }
-                    });
-                }
-            },
-            PumpSwapSellEvent => |e: PumpSwapSellEvent| {
-                let is_wsol = e.base_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT || e.quote_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT;
-                let is_usdc = e.base_mint == sol_trade_sdk::constants::USDC_TOKEN_ACCOUNT || e.quote_mint == sol_trade_sdk::constants::USDC_TOKEN_ACCOUNT;
-                if !is_wsol && !is_usdc {
-                    return;
-                }
-                if !selection.matches(e.pool, e.base_mint, e.quote_mint, e.metadata.recv_us) {
-                    return;
-                }
-                // Test code, only test one transaction
-                if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
-                    let event_clone = e.clone();
-                    let client = client.clone();
-                    let blockhash_cache = blockhash_cache.clone();
-                    tokio::spawn(async move {
-                        if let Err(err) = pumpswap_trade_with_grpc_sell_event(
-                            client,
-                            blockhash_cache,
-                            event_clone,
-                        ).await {
-                            eprintln!("Error in trade: {:?}", err);
-                            std::process::exit(1);
-                        }
-                    });
-                }
+) -> impl Fn(DexEvent) {
+    move |event: DexEvent| match event {
+        DexEvent::PumpSwapBuyEvent(e) => {
+            let is_wsol = e.base_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT
+                || e.quote_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT;
+            let is_usdc = e.base_mint == sol_trade_sdk::constants::USDC_TOKEN_ACCOUNT
+                || e.quote_mint == sol_trade_sdk::constants::USDC_TOKEN_ACCOUNT;
+            if !is_wsol && !is_usdc {
+                return;
             }
-        });
+            if !selection.matches(e.pool, e.base_mint, e.quote_mint, e.metadata.recv_us) {
+                return;
+            }
+            // Test code, only test one transaction
+            if ALREADY_EXECUTED
+                .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+                .is_ok()
+            {
+                let client = client.clone();
+                let blockhash_cache = blockhash_cache.clone();
+                let position_baseline = position_baseline.clone();
+                let was_preparing =
+                    position_baseline.read().map(|baseline| baseline.is_none()).unwrap_or(true);
+                tokio::spawn(async move {
+                    match pumpswap_trade_with_grpc_buy_event(
+                        client,
+                        blockhash_cache,
+                        position_baseline,
+                        selection,
+                        e,
+                    )
+                    .await
+                    {
+                        Ok(EventAction::BaselineWarmed) => {
+                            ALREADY_EXECUTED.store(false, Ordering::Release);
+                        }
+                        Ok(EventAction::TradeCompleted) => {}
+                        Err(err) if was_preparing => {
+                            eprintln!("baseline warmup failed; waiting for a later event: {err:?}");
+                            ALREADY_EXECUTED.store(false, Ordering::Release);
+                        }
+                        Err(err) => {
+                            eprintln!(
+                                "trade failed after entering execution state: {err:?}; automatic retry is disabled because submission status or position state may be uncertain"
+                            );
+                        }
+                    }
+                });
+            }
+        }
+        DexEvent::PumpSwapSellEvent(e) => {
+            let is_wsol = e.base_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT
+                || e.quote_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT;
+            let is_usdc = e.base_mint == sol_trade_sdk::constants::USDC_TOKEN_ACCOUNT
+                || e.quote_mint == sol_trade_sdk::constants::USDC_TOKEN_ACCOUNT;
+            if !is_wsol && !is_usdc {
+                return;
+            }
+            if !selection.matches(e.pool, e.base_mint, e.quote_mint, e.metadata.recv_us) {
+                return;
+            }
+            // Test code, only test one transaction
+            if ALREADY_EXECUTED
+                .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+                .is_ok()
+            {
+                let client = client.clone();
+                let blockhash_cache = blockhash_cache.clone();
+                let position_baseline = position_baseline.clone();
+                let was_preparing =
+                    position_baseline.read().map(|baseline| baseline.is_none()).unwrap_or(true);
+                tokio::spawn(async move {
+                    match pumpswap_trade_with_grpc_sell_event(
+                        client,
+                        blockhash_cache,
+                        position_baseline,
+                        selection,
+                        e,
+                    )
+                    .await
+                    {
+                        Ok(EventAction::BaselineWarmed) => {
+                            ALREADY_EXECUTED.store(false, Ordering::Release);
+                        }
+                        Ok(EventAction::TradeCompleted) => {}
+                        Err(err) if was_preparing => {
+                            eprintln!("baseline warmup failed; waiting for a later event: {err:?}");
+                            ALREADY_EXECUTED.store(false, Ordering::Release);
+                        }
+                        Err(err) => {
+                            eprintln!(
+                                "trade failed after entering execution state: {err:?}; automatic retry is disabled because submission status or position state may be uncertain"
+                            );
+                        }
+                    }
+                });
+            }
+        }
+        _ => {}
     }
 }
 
@@ -277,8 +335,10 @@ async fn create_solana_trade_client() -> AnyResult<SolanaTrade> {
 async fn pumpswap_trade_with_grpc_buy_event(
     client: Arc<SolanaTrade>,
     blockhash_cache: BlockhashCache,
+    position_baseline: Arc<RwLock<Option<PositionBaseline>>>,
+    selection: EventSelection,
     trade_info: PumpSwapBuyEvent,
-) -> AnyResult<()> {
+) -> AnyResult<EventAction> {
     let params = PumpSwapParams::from_trade_with_fee_basis_points(
         trade_info.pool,
         trade_info.base_mint,
@@ -287,6 +347,7 @@ async fn pumpswap_trade_with_grpc_buy_event(
         trade_info.pool_quote_token_account,
         trade_info.pool_base_token_reserves,
         trade_info.pool_quote_token_reserves,
+        trade_info.virtual_quote_reserves,
         trade_info.coin_creator_vault_ata,
         trade_info.coin_creator_vault_authority,
         trade_info.base_token_program,
@@ -294,8 +355,8 @@ async fn pumpswap_trade_with_grpc_buy_event(
         trade_info.protocol_fee_recipient,
         Pubkey::default(),
         trade_info.coin_creator,
-        false,
-        0,
+        trade_info.cashback_fee_basis_points != 0 || trade_info.cashback != 0,
+        trade_info.cashback_fee_basis_points,
         trade_info.lp_fee_basis_points,
         trade_info.protocol_fee_basis_points,
         trade_info.coin_creator_fee_basis_points,
@@ -307,16 +368,25 @@ async fn pumpswap_trade_with_grpc_buy_event(
     } else {
         trade_info.base_mint
     };
-    pumpswap_trade_with_grpc(&client, &blockhash_cache, trade_info.metadata.recv_us, mint, params)
-        .await?;
-    Ok(())
+    pumpswap_trade_with_grpc(
+        &client,
+        &blockhash_cache,
+        &position_baseline,
+        trade_info.metadata.recv_us,
+        selection.max_event_age_ms,
+        mint,
+        params,
+    )
+    .await
 }
 
 async fn pumpswap_trade_with_grpc_sell_event(
     client: Arc<SolanaTrade>,
     blockhash_cache: BlockhashCache,
+    position_baseline: Arc<RwLock<Option<PositionBaseline>>>,
+    selection: EventSelection,
     trade_info: PumpSwapSellEvent,
-) -> AnyResult<()> {
+) -> AnyResult<EventAction> {
     let params = PumpSwapParams::from_trade_with_fee_basis_points(
         trade_info.pool,
         trade_info.base_mint,
@@ -325,6 +395,7 @@ async fn pumpswap_trade_with_grpc_sell_event(
         trade_info.pool_quote_token_account,
         trade_info.pool_base_token_reserves,
         trade_info.pool_quote_token_reserves,
+        trade_info.virtual_quote_reserves,
         trade_info.coin_creator_vault_ata,
         trade_info.coin_creator_vault_authority,
         trade_info.base_token_program,
@@ -332,8 +403,8 @@ async fn pumpswap_trade_with_grpc_sell_event(
         trade_info.protocol_fee_recipient,
         Pubkey::default(),
         trade_info.coin_creator,
-        false,
-        0,
+        trade_info.cashback_fee_basis_points != 0 || trade_info.cashback != 0,
+        trade_info.cashback_fee_basis_points,
         trade_info.lp_fee_basis_points,
         trade_info.protocol_fee_basis_points,
         trade_info.coin_creator_fee_basis_points,
@@ -345,24 +416,33 @@ async fn pumpswap_trade_with_grpc_sell_event(
     } else {
         trade_info.base_mint
     };
-    pumpswap_trade_with_grpc(&client, &blockhash_cache, trade_info.metadata.recv_us, mint, params)
-        .await?;
-    Ok(())
+    pumpswap_trade_with_grpc(
+        &client,
+        &blockhash_cache,
+        &position_baseline,
+        trade_info.metadata.recv_us,
+        selection.max_event_age_ms,
+        mint,
+        params,
+    )
+    .await
 }
 
 async fn pumpswap_trade_with_grpc(
     client: &SolanaTrade,
     blockhash_cache: &BlockhashCache,
+    position_baseline: &Arc<RwLock<Option<PositionBaseline>>>,
     grpc_recv_us: i64,
+    max_event_age_ms: u64,
     mint_pubkey: Pubkey,
     params: PumpSwapParams,
-) -> AnyResult<()> {
+) -> AnyResult<EventAction> {
     println!("Testing PumpSwap trading...");
+    validate_pumpswap_snapshot(&params)?;
+    if !is_event_fresh(grpc_recv_us, now_micros(), max_event_age_ms) {
+        anyhow::bail!("event became stale before transaction construction");
+    }
     let slippage_basis_points = Some(500);
-    let recent_blockhash = blockhash_cache.latest()?;
-
-    let gas_fee_strategy = sol_trade_sdk::common::GasFeeStrategy::new();
-    gas_fee_strategy.set_global_fee_strategy(150000, 150000, 500000, 500000, 0.001, 0.001);
 
     let is_sol = params.base_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT
         || params.quote_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT;
@@ -373,8 +453,35 @@ async fn pumpswap_trade_with_grpc(
     } else {
         anyhow::bail!("target mint {} does not belong to pool {}", mint_pubkey, params.pool);
     };
-    let balance_before =
-        client.get_payer_token_balance_with_program(&mint_pubkey, &program_id).await?;
+    let baseline = position_baseline
+        .read()
+        .map_err(|_| anyhow::anyhow!("position baseline lock is poisoned"))?
+        .as_ref()
+        .copied();
+    let balance_before = if let Some(baseline) = baseline {
+        if baseline.mint != mint_pubkey || baseline.token_program != program_id {
+            anyhow::bail!("cached position baseline belongs to a different mint or token program");
+        }
+        baseline.amount
+    } else {
+        let amount = client.get_payer_token_balance_with_program(&mint_pubkey, &program_id).await?;
+        let mut baseline = position_baseline
+            .write()
+            .map_err(|_| anyhow::anyhow!("position baseline lock is poisoned"))?;
+        *baseline = Some(PositionBaseline { mint: mint_pubkey, token_program: program_id, amount });
+        println!(
+            "Position baseline warmed at {} base units; waiting for the next fresh matching event",
+            amount
+        );
+        return Ok(EventAction::BaselineWarmed);
+    };
+
+    let recent_blockhash = blockhash_cache.latest()?;
+    let gas_fee_strategy = sol_trade_sdk::common::GasFeeStrategy::new();
+    gas_fee_strategy.set_global_fee_strategy(150000, 150000, 500000, 500000, 0.001, 0.001);
+    if !is_event_fresh(grpc_recv_us, now_micros(), max_event_age_ms) {
+        anyhow::bail!("event became stale while preparing the transaction");
+    }
 
     // Buy tokens
     println!("Buying tokens from PumpSwap...");
@@ -432,8 +539,32 @@ async fn pumpswap_trade_with_grpc(
         anyhow::bail!("sell failed: {:?}; signatures: {:?}", err, sigs);
     }
 
-    // Exit program
-    std::process::exit(0);
+    println!("Round-trip example completed; further matching events remain locked out");
+    Ok(EventAction::TradeCompleted)
+}
+
+fn validate_pumpswap_snapshot(params: &PumpSwapParams) -> AnyResult<()> {
+    let required = [
+        ("pool", params.pool),
+        ("base_mint", params.base_mint),
+        ("quote_mint", params.quote_mint),
+        ("pool_base_token_account", params.pool_base_token_account),
+        ("pool_quote_token_account", params.pool_quote_token_account),
+        ("coin_creator_vault_ata", params.coin_creator_vault_ata),
+        ("coin_creator_vault_authority", params.coin_creator_vault_authority),
+        ("base_token_program", params.base_token_program),
+        ("quote_token_program", params.quote_token_program),
+    ];
+    for (name, value) in required {
+        if value == Pubkey::default() {
+            anyhow::bail!("event snapshot is missing {name}");
+        }
+    }
+    if params.pool_base_token_reserves == 0 || params.pool_quote_token_reserves == 0 {
+        anyhow::bail!("event snapshot has an empty raw pool reserve");
+    }
+    params.effective_quote_reserves()?;
+    Ok(())
 }
 
 #[cfg(test)]

examples/raydium_amm_v4_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-solana-streamer-sdk = "0.5.0"
+solana-streamer-sdk = { version = "2.0.0", git = "https://github.com/0xfnzero/solana-streamer", rev = "f1c6aecb3d4a4ebb2cd3c9f6a58de20b019418e2" }
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/raydium_amm_v4_trading/src/main.rs

@@ -12,12 +12,10 @@ use solana_commitment_config::CommitmentConfig;
 use solana_streamer_sdk::streaming::event_parser::common::filter::EventTypeFilter;
 use solana_streamer_sdk::streaming::event_parser::common::EventType;
 use solana_streamer_sdk::streaming::event_parser::protocols::raydium_amm_v4::parser::RAYDIUM_AMM_V4_PROGRAM_ID;
-use solana_streamer_sdk::streaming::event_parser::{Protocol, UnifiedEvent};
-use solana_streamer_sdk::streaming::yellowstone_grpc::{AccountFilter, TransactionFilter};
+use solana_streamer_sdk::streaming::event_parser::protocols::raydium_amm_v4::RaydiumAmmV4SwapEvent;
+use solana_streamer_sdk::streaming::event_parser::{DexEvent, Protocol};
+use solana_streamer_sdk::streaming::yellowstone_grpc::TransactionFilter;
 use solana_streamer_sdk::streaming::YellowstoneGrpc;
-use solana_streamer_sdk::{
-    match_event, streaming::event_parser::protocols::raydium_amm_v4::RaydiumAmmV4SwapEvent,
-};
 use std::sync::{
     atomic::{AtomicBool, Ordering},
     Arc,
@@ -51,19 +49,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         account_required,
     };
 
-    // Listen to account data belonging to owner programs -> account event monitoring
-    let account_filter = AccountFilter { account: vec![], owner: vec![], filters: vec![] };
-
     // listen to specific event type
-    let event_type_filter = EventTypeFilter {
-        include: vec![EventType::RaydiumAmmV4SwapBaseIn, EventType::RaydiumAmmV4SwapBaseOut],
-    };
+    let event_type_filter = EventTypeFilter::include_only(vec![
+        EventType::RaydiumAmmV4SwapBaseIn,
+        EventType::RaydiumAmmV4SwapBaseOut,
+    ]);
 
     grpc.subscribe_events_immediate(
         protocols,
         None,
         vec![transaction_filter],
-        vec![account_filter],
+        vec![],
         Some(event_type_filter),
         None,
         callback,
@@ -71,27 +67,25 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     .await?;
 
     tokio::signal::ctrl_c().await?;
+    grpc.stop().await;
 
     Ok(())
 }
 
 /// Create an event callback function that handles different types of events
-fn create_event_callback() -> impl Fn(Box<dyn UnifiedEvent>) {
-    |event: Box<dyn UnifiedEvent>| {
-        match_event!(event, {
-            RaydiumAmmV4SwapEvent => |e: RaydiumAmmV4SwapEvent| {
-                // Test code, only test one transaction
-                if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
-                    let event_clone = e.clone();
-                    tokio::spawn(async move {
-                        if let Err(err) = raydium_amm_v4_copy_trade_with_grpc(event_clone).await {
-                            eprintln!("Error in copy trade: {:?}", err);
-                            std::process::exit(1);
-                        }
-                    });
+fn create_event_callback() -> impl Fn(DexEvent) {
+    |event: DexEvent| {
+        let DexEvent::RaydiumAmmV4SwapEvent(event) = event else {
+            return;
+        };
+        if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
+            tokio::spawn(async move {
+                if let Err(err) = raydium_amm_v4_copy_trade_with_grpc(event).await {
+                    eprintln!("Error in copy trade: {:?}", err);
+                    std::process::exit(1);
                 }
-            },
-        });
+            });
+        }
     }
 }
 

examples/raydium_cpmm_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-solana-streamer-sdk = "0.5.0"
+solana-streamer-sdk = { version = "2.0.0", git = "https://github.com/0xfnzero/solana-streamer", rev = "f1c6aecb3d4a4ebb2cd3c9f6a58de20b019418e2" }
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/raydium_cpmm_trading/src/main.rs

@@ -8,12 +8,10 @@ use solana_commitment_config::CommitmentConfig;
 use solana_streamer_sdk::streaming::event_parser::common::filter::EventTypeFilter;
 use solana_streamer_sdk::streaming::event_parser::common::EventType;
 use solana_streamer_sdk::streaming::event_parser::protocols::raydium_cpmm::parser::RAYDIUM_CPMM_PROGRAM_ID;
-use solana_streamer_sdk::streaming::event_parser::{Protocol, UnifiedEvent};
-use solana_streamer_sdk::streaming::yellowstone_grpc::{AccountFilter, TransactionFilter};
+use solana_streamer_sdk::streaming::event_parser::protocols::raydium_cpmm::RaydiumCpmmSwapEvent;
+use solana_streamer_sdk::streaming::event_parser::{DexEvent, Protocol};
+use solana_streamer_sdk::streaming::yellowstone_grpc::TransactionFilter;
 use solana_streamer_sdk::streaming::YellowstoneGrpc;
-use solana_streamer_sdk::{
-    match_event, streaming::event_parser::protocols::raydium_cpmm::RaydiumCpmmSwapEvent,
-};
 use std::sync::{
     atomic::{AtomicBool, Ordering},
     Arc,
@@ -47,19 +45,17 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         account_required,
     };
 
-    // Listen to account data belonging to owner programs -> account event monitoring
-    let account_filter = AccountFilter { account: vec![], owner: vec![], filters: vec![] };
-
     // listen to specific event type
-    let event_type_filter = EventTypeFilter {
-        include: vec![EventType::RaydiumCpmmSwapBaseInput, EventType::RaydiumCpmmSwapBaseOutput],
-    };
+    let event_type_filter = EventTypeFilter::include_only(vec![
+        EventType::RaydiumCpmmSwapBaseInput,
+        EventType::RaydiumCpmmSwapBaseOutput,
+    ]);
 
     grpc.subscribe_events_immediate(
         protocols,
         None,
         vec![transaction_filter],
-        vec![account_filter],
+        vec![],
         Some(event_type_filter),
         None,
         callback,
@@ -67,32 +63,32 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     .await?;
 
     tokio::signal::ctrl_c().await?;
+    grpc.stop().await;
 
     Ok(())
 }
 
 /// Create an event callback function that handles different types of events
-fn create_event_callback() -> impl Fn(Box<dyn UnifiedEvent>) {
-    |event: Box<dyn UnifiedEvent>| {
-        match_event!(event, {
-            RaydiumCpmmSwapEvent => |e: RaydiumCpmmSwapEvent| {
-                let is_wsol = e.input_token_mint == WSOL_TOKEN_ACCOUNT || e.output_token_mint == WSOL_TOKEN_ACCOUNT;
-                let is_usdc = e.input_token_mint == USDC_TOKEN_ACCOUNT || e.output_token_mint == USDC_TOKEN_ACCOUNT;
-                if !is_wsol && !is_usdc {
-                    return;
+fn create_event_callback() -> impl Fn(DexEvent) {
+    |event: DexEvent| {
+        let DexEvent::RaydiumCpmmSwapEvent(event) = event else {
+            return;
+        };
+        let is_wsol = event.input_token_mint == WSOL_TOKEN_ACCOUNT
+            || event.output_token_mint == WSOL_TOKEN_ACCOUNT;
+        let is_usdc = event.input_token_mint == USDC_TOKEN_ACCOUNT
+            || event.output_token_mint == USDC_TOKEN_ACCOUNT;
+        if !is_wsol && !is_usdc {
+            return;
+        }
+        if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
+            tokio::spawn(async move {
+                if let Err(err) = raydium_cpmm_copy_trade_with_grpc(event).await {
+                    eprintln!("Error in copy trade: {:?}", err);
+                    std::process::exit(1);
                 }
-                // Test code, only test one transaction
-                if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
-                    let event_clone = e.clone();
-                    tokio::spawn(async move {
-                        if let Err(err) = raydium_cpmm_copy_trade_with_grpc(event_clone).await {
-                            eprintln!("Error in copy trade: {:?}", err);
-                            std::process::exit(1);
-                        }
-                    });
-                }
-            },
-        });
+            });
+        }
     }
 }
 

examples/seed_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-solana-streamer-sdk = "0.5.0"
+solana-streamer-sdk = { version = "2.0.0", git = "https://github.com/0xfnzero/solana-streamer", rev = "f1c6aecb3d4a4ebb2cd3c9f6a58de20b019418e2" }
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

idl/pump_amm.json

@@ -288,6 +288,213 @@
         }
       ]
     },
+    {
+      "name": "boost_buy_and_burn",
+      "discriminator": [
+        105,
+        68,
+        6,
+        175,
+        0,
+        7,
+        35,
+        162
+      ],
+      "accounts": [
+        {
+          "name": "pool"
+        },
+        {
+          "name": "authority",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "global_config",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  103,
+                  108,
+                  111,
+                  98,
+                  97,
+                  108,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "base_mint",
+          "writable": true,
+          "relations": [
+            "pool"
+          ]
+        },
+        {
+          "name": "quote_mint",
+          "relations": [
+            "pool"
+          ]
+        },
+        {
+          "name": "pool_base_token_account",
+          "writable": true,
+          "relations": [
+            "pool"
+          ]
+        },
+        {
+          "name": "pool_quote_token_account",
+          "writable": true,
+          "relations": [
+            "pool"
+          ]
+        },
+        {
+          "name": "boost_vault_authority",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  98,
+                  111,
+                  111,
+                  115,
+                  116,
+                  95,
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "pool"
+              }
+            ]
+          }
+        },
+        {
+          "name": "boost_vault",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "account",
+                "path": "boost_vault_authority"
+              },
+              {
+                "kind": "account",
+                "path": "quote_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": "base_token_program"
+        },
+        {
+          "name": "quote_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": "quote_amount_in",
+          "type": "u64"
+        },
+        {
+          "name": "min_base_amount_burned",
+          "type": "u64"
+        }
+      ]
+    },
     {
       "name": "buy",
       "docs": [
@@ -2587,6 +2794,208 @@
       ],
       "args": []
     },
+    {
+      "name": "init_boost",
+      "discriminator": [
+        140,
+        233,
+        33,
+        94,
+        132,
+        90,
+        194,
+        143
+      ],
+      "accounts": [
+        {
+          "name": "pool",
+          "writable": true
+        },
+        {
+          "name": "global_config",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  103,
+                  108,
+                  111,
+                  98,
+                  97,
+                  108,
+                  95,
+                  99,
+                  111,
+                  110,
+                  102,
+                  105,
+                  103
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "creator",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "base_mint",
+          "relations": [
+            "pool"
+          ]
+        },
+        {
+          "name": "quote_mint",
+          "relations": [
+            "pool"
+          ]
+        },
+        {
+          "name": "pool_base_token_account",
+          "relations": [
+            "pool"
+          ]
+        },
+        {
+          "name": "pool_quote_token_account",
+          "writable": true,
+          "relations": [
+            "pool"
+          ]
+        },
+        {
+          "name": "boost_vault_authority",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  98,
+                  111,
+                  111,
+                  115,
+                  116,
+                  95,
+                  118,
+                  97,
+                  117,
+                  108,
+                  116
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "pool"
+              }
+            ]
+          }
+        },
+        {
+          "name": "boost_vault",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "account",
+                "path": "boost_vault_authority"
+              },
+              {
+                "kind": "account",
+                "path": "quote_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": "quote_token_program"
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        },
+        {
+          "name": "associated_token_program",
+          "address": "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+        },
+        {
+          "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": "init_user_volume_accumulator",
       "discriminator": [
@@ -3175,6 +3584,72 @@
         }
       ]
     },
+    {
+      "name": "set_boost_authority",
+      "discriminator": [
+        227,
+        149,
+        76,
+        42,
+        130,
+        39,
+        234,
+        205
+      ],
+      "accounts": [
+        {
+          "name": "admin",
+          "signer": true,
+          "relations": [
+            "global_config"
+          ]
+        },
+        {
+          "name": "global_config",
+          "writable": true
+        },
+        {
+          "name": "boost_authority"
+        },
+        {
+          "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": "set_coin_creator",
       "docs": [
@@ -3610,6 +4085,38 @@
       ],
       "args": []
     },
+    {
+      "name": "toggle_boost",
+      "discriminator": [
+        117,
+        161,
+        160,
+        74,
+        223,
+        137,
+        118,
+        99
+      ],
+      "accounts": [
+        {
+          "name": "admin",
+          "signer": true,
+          "relations": [
+            "global_config"
+          ]
+        },
+        {
+          "name": "global_config",
+          "writable": true
+        }
+      ],
+      "args": [
+        {
+          "name": "enabled",
+          "type": "bool"
+        }
+      ]
+    },
     {
       "name": "toggle_cashback_enabled",
       "discriminator": [
@@ -4672,6 +5179,19 @@
         222
       ]
     },
+    {
+      "name": "BoostBuyAndBurnEvent",
+      "discriminator": [
+        63,
+        69,
+        28,
+        22,
+        48,
+        92,
+        194,
+        185
+      ]
+    },
     {
       "name": "BuyEvent",
       "discriminator": [
@@ -4802,6 +5322,19 @@
         124
       ]
     },
+    {
+      "name": "InitBoostEvent",
+      "discriminator": [
+        174,
+        124,
+        74,
+        249,
+        4,
+        81,
+        246,
+        17
+      ]
+    },
     {
       "name": "InitUserVolumeAccumulatorEvent",
       "discriminator": [
@@ -4867,6 +5400,19 @@
         211
       ]
     },
+    {
+      "name": "SetBoostAuthorityEvent",
+      "discriminator": [
+        89,
+        128,
+        240,
+        141,
+        91,
+        202,
+        71,
+        105
+      ]
+    },
     {
       "name": "SetMetaplexCoinCreatorEvent",
       "discriminator": [
@@ -5177,6 +5723,51 @@
     {
       "code": 6058,
       "name": "BuybackFeeRecipientMissing"
+    },
+    {
+      "code": 6059,
+      "name": "MissingCashbackAccounts",
+      "msg": "Cashback trade is missing the required remaining accounts"
+    },
+    {
+      "code": 6060,
+      "name": "InvalidCashbackAccumulator",
+      "msg": "Cashback user_volume_accumulator account is invalid"
+    },
+    {
+      "code": 6061,
+      "name": "InvalidCashbackAccumulatorAta",
+      "msg": "Cashback user_volume_accumulator ATA is missing or invalid"
+    },
+    {
+      "code": 6062,
+      "name": "InvalidPoolV2",
+      "msg": "pool_v2 remaining account is missing or invalid"
+    },
+    {
+      "code": 6063,
+      "name": "InsufficientRealQuoteReserves",
+      "msg": "BOOST: sell output exceeds the real quote vault. effective = real + virtual is pricing-only; payout is capped at real_vault, so quote min(out, real_vault)"
+    },
+    {
+      "code": 6064,
+      "name": "BoostPoolLiquidityUnsupported",
+      "msg": "BOOST: deposit/withdraw don't apply to boost pools"
+    },
+    {
+      "code": 6065,
+      "name": "PoolCannotBoost",
+      "msg": "BOOST: pool cannot be boosted (no virtual reserves)"
+    },
+    {
+      "code": 6066,
+      "name": "BoostDisabled",
+      "msg": "BOOST: boost is disabled"
+    },
+    {
+      "code": 6067,
+      "name": "SeedLockViolation",
+      "msg": "BOOST: lp_supply must never drop below the circulating LP mint supply"
     }
   ],
   "types": [
@@ -5292,6 +5883,62 @@
         ]
       }
     },
+    {
+      "name": "BoostBuyAndBurnEvent",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "timestamp",
+            "type": "i64"
+          },
+          {
+            "name": "mint",
+            "type": "pubkey"
+          },
+          {
+            "name": "bonding_curve",
+            "type": "pubkey"
+          },
+          {
+            "name": "pool",
+            "type": "pubkey"
+          },
+          {
+            "name": "authority",
+            "type": "pubkey"
+          },
+          {
+            "name": "quote_amount_in_requested",
+            "type": "u64"
+          },
+          {
+            "name": "quote_amount_in_used",
+            "type": "u64"
+          },
+          {
+            "name": "base_amount_burned",
+            "type": "u64"
+          },
+          {
+            "name": "virtual_quote_reserves",
+            "type": "i128"
+          },
+          {
+            "name": "real_quote_reserves_after",
+            "type": "u64"
+          },
+          {
+            "name": "base_reserves_after",
+            "type": "u64"
+          },
+          {
+            "name": "boost_vault_remaining",
+            "type": "u64"
+          }
+        ]
+      }
+    },
     {
       "name": "BuyEvent",
       "docs": [
@@ -5435,6 +6082,18 @@
           {
             "name": "buyback_fee",
             "type": "u64"
+          },
+          {
+            "name": "virtual_quote_reserves",
+            "type": "i128"
+          },
+          {
+            "name": "can_boost",
+            "type": "bool"
+          },
+          {
+            "name": "base_supply",
+            "type": "u64"
           }
         ]
       }
@@ -6018,6 +6677,14 @@
           {
             "name": "buyback_basis_points",
             "type": "u64"
+          },
+          {
+            "name": "boost_authority",
+            "type": "pubkey"
+          },
+          {
+            "name": "boost_enabled",
+            "type": "bool"
           }
         ]
       }
@@ -6064,6 +6731,38 @@
         ]
       }
     },
+    {
+      "name": "InitBoostEvent",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "timestamp",
+            "type": "i64"
+          },
+          {
+            "name": "mint",
+            "type": "pubkey"
+          },
+          {
+            "name": "bonding_curve",
+            "type": "pubkey"
+          },
+          {
+            "name": "pool",
+            "type": "pubkey"
+          },
+          {
+            "name": "virtual_quote_reserves",
+            "type": "i128"
+          },
+          {
+            "name": "real_quote_reserves_after",
+            "type": "u64"
+          }
+        ]
+      }
+    },
     {
       "name": "InitUserVolumeAccumulatorEvent",
       "type": {
@@ -6180,6 +6879,13 @@
           {
             "name": "is_cashback_coin",
             "type": "bool"
+          },
+          {
+            "name": "virtual_quote_reserves",
+            "docs": [
+              "For non-boost pools, value is 0, so the behavior is identical to legacy pools."
+            ],
+            "type": "i128"
           }
         ]
       }
@@ -6321,6 +7027,18 @@
           {
             "name": "buyback_fee",
             "type": "u64"
+          },
+          {
+            "name": "virtual_quote_reserves",
+            "type": "i128"
+          },
+          {
+            "name": "can_boost",
+            "type": "bool"
+          },
+          {
+            "name": "base_supply",
+            "type": "u64"
           }
         ]
       }
@@ -6353,6 +7071,30 @@
         ]
       }
     },
+    {
+      "name": "SetBoostAuthorityEvent",
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "timestamp",
+            "type": "i64"
+          },
+          {
+            "name": "admin",
+            "type": "pubkey"
+          },
+          {
+            "name": "old_boost_authority",
+            "type": "pubkey"
+          },
+          {
+            "name": "new_boost_authority",
+            "type": "pubkey"
+          }
+        ]
+      }
+    },
     {
       "name": "SetMetaplexCoinCreatorEvent",
       "type": {

src/instruction/pumpswap.rs

@@ -2,7 +2,7 @@ use crate::{
     constants::trade::trade::DEFAULT_SLIPPAGE,
     instruction::pumpswap_ix_data::{
         encode_pumpswap_buy_exact_quote_in_ix_data, encode_pumpswap_buy_ix_data,
-        encode_pumpswap_buy_two_args, encode_pumpswap_sell_ix_data,
+        encode_pumpswap_sell_ix_data,
     },
     instruction::{
         token_account_setup::{
@@ -34,6 +34,38 @@ use solana_sdk::{
 /// Instruction builder for PumpSwap protocol
 pub struct PumpSwapInstructionBuilder;
 
+#[inline]
+fn request_mint_matches_pool(actual: Pubkey, expected: Pubkey) -> bool {
+    actual == expected
+        || (expected == crate::constants::WSOL_TOKEN_ACCOUNT
+            && actual == crate::constants::SOL_TOKEN_ACCOUNT)
+}
+
+fn push_cashback_remaining_accounts(
+    accounts: &mut Vec<AccountMeta>,
+    user: &Pubkey,
+    quote_mint: &Pubkey,
+    quote_token_program: &Pubkey,
+    is_cashback_coin: bool,
+    is_buy_instruction: bool,
+) -> Result<()> {
+    if !is_cashback_coin {
+        return Ok(());
+    }
+
+    let quote_ata = get_user_volume_accumulator_quote_ata(user, quote_mint, quote_token_program)
+        .ok_or_else(|| anyhow!("user volume accumulator quote ATA derivation failed"))?;
+    accounts.push(AccountMeta::new(quote_ata, false));
+
+    if !is_buy_instruction {
+        let accumulator = get_user_volume_accumulator_pda(user)
+            .ok_or_else(|| anyhow!("user volume accumulator PDA derivation failed"))?;
+        accounts.push(AccountMeta::new(accumulator, false));
+    }
+
+    Ok(())
+}
+
 #[async_trait::async_trait]
 impl InstructionBuilder for PumpSwapInstructionBuilder {
     async fn build_buy_instructions(&self, params: &SwapParams) -> Result<Vec<Instruction>> {
@@ -49,12 +81,17 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
         if params.input_amount.unwrap_or(0) == 0 {
             return Err(anyhow!("Amount cannot be zero"));
         }
+        if params.fixed_output_amount == Some(0) {
+            return Err(anyhow!("Fixed output amount cannot be zero"));
+        }
 
         let pool = protocol_params.pool;
         let base_mint = protocol_params.base_mint;
         let quote_mint = protocol_params.quote_mint;
         let pool_base_token_reserves = protocol_params.pool_base_token_reserves;
         let pool_quote_token_reserves = protocol_params.pool_quote_token_reserves;
+        let virtual_quote_reserves = protocol_params.virtual_quote_reserves;
+        protocol_params.effective_quote_reserves()?;
         let params_coin_creator_vault_ata = protocol_params.coin_creator_vault_ata;
         let params_coin_creator_vault_authority = protocol_params.coin_creator_vault_authority;
         let create_input_ata = params.create_input_mint_ata;
@@ -81,15 +118,28 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
         // ========================================
         let quote_is_wsol_or_usdc = quote_mint == crate::constants::WSOL_TOKEN_ACCOUNT
             || quote_mint == crate::constants::USDC_TOKEN_ACCOUNT;
+        if params.fixed_output_amount.is_some() && !quote_is_wsol_or_usdc {
+            return Err(anyhow!(
+                "PumpSwap exact-output buy is unsupported when the pool requires a sell instruction"
+            ));
+        }
         let input_stable_mint = if quote_is_wsol_or_usdc { quote_mint } else { base_mint };
         let input_stable_token_program =
             if quote_is_wsol_or_usdc { quote_token_program } else { base_token_program };
         let output_trade_mint = if quote_is_wsol_or_usdc { base_mint } else { quote_mint };
         let output_trade_token_program =
             if quote_is_wsol_or_usdc { base_token_program } else { quote_token_program };
+        if !request_mint_matches_pool(params.input_mint, input_stable_mint)
+            || !request_mint_matches_pool(params.output_mint, output_trade_mint)
+        {
+            return Err(anyhow!("PumpSwap buy request mints do not match the supplied pool"));
+        }
         let fee_basis_points = protocol_params.fee_basis_points;
 
         let (token_amount, sol_amount) = if let Some(output_amount) = params.fixed_output_amount {
+            if output_amount >= pool_base_token_reserves {
+                return Err(anyhow!("Exact base output must be below the pool base reserve"));
+            }
             (output_amount, params.input_amount.unwrap_or(0))
         } else if quote_is_wsol_or_usdc {
             let result = buy_quote_input_internal_with_fees(
@@ -97,9 +147,10 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
                 params.slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE),
                 pool_base_token_reserves,
                 pool_quote_token_reserves,
+                virtual_quote_reserves,
                 &fee_basis_points,
             )
-            .unwrap();
+            .map_err(anyhow::Error::msg)?;
             // base_amount_out, max_quote_amount_in
             (result.base, result.max_quote)
         } else {
@@ -108,9 +159,10 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
                 params.slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE),
                 pool_base_token_reserves,
                 pool_quote_token_reserves,
+                virtual_quote_reserves,
                 &fee_basis_points,
             )
-            .unwrap();
+            .map_err(anyhow::Error::msg)?;
             // min_quote_amount_out, base_amount_in
             (result.min_quote, params.input_amount.unwrap_or(0))
         };
@@ -138,7 +190,7 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
             let recipient = get_protocol_fee_recipient_random();
             (recipient, AccountMeta::new_readonly(recipient, false))
         };
-        let fee_recipient_ata = fee_recipient_ata(fee_recipient, quote_mint);
+        let fee_recipient_ata = fee_recipient_ata(fee_recipient, quote_mint, quote_token_program);
 
         // ========================================
         // Build instructions
@@ -206,12 +258,14 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
         }
         accounts.push(accounts::FEE_CONFIG_META);
         accounts.push(accounts::FEE_PROGRAM_META);
-        // Cashback: remaining_accounts[0] = WSOL ATA of UserVolumeAccumulator (after named accounts per IDL)
-        if protocol_params.is_cashback_coin {
-            if let Some(wsol_ata) = get_user_volume_accumulator_wsol_ata(&params.payer.pubkey()) {
-                accounts.push(AccountMeta::new(wsol_ata, false));
-            }
-        }
+        push_cashback_remaining_accounts(
+            &mut accounts,
+            &params.payer.pubkey(),
+            &quote_mint,
+            &quote_token_program,
+            protocol_params.is_cashback_coin,
+            quote_is_wsol_or_usdc,
+        )?;
         // `pool-v2` only when coin_creator ≠ default (@pump-fun/pump-swap-sdk remainingAccounts)；
         // 否则多出的一格会把 buyback pubkey 错位，触发 BuybackFeeRecipientNotAuthorized（6053）。
         if protocol_params.coin_creator != Pubkey::default() {
@@ -224,12 +278,16 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
         let protocol_extra = get_protocol_extra_fee_recipient_random();
         accounts.push(AccountMeta::new_readonly(protocol_extra, false));
         accounts.push(AccountMeta::new(
-            crate::instruction::utils::pumpswap::fee_recipient_ata(protocol_extra, quote_mint),
+            crate::instruction::utils::pumpswap::fee_recipient_ata(
+                protocol_extra,
+                quote_mint,
+                quote_token_program,
+            ),
             false,
         ));
 
         // buy / buy_exact_quote_in：栈上 `[u8;25]` + `new_with_bytes`，避免每笔 `Vec` 堆分配。
-        let track_volume: u8 = if protocol_params.is_cashback_coin { 1 } else { 0 };
+        let track_volume = 1_u8;
         if quote_is_wsol_or_usdc {
             let ix_data = if params.fixed_output_amount.is_some() {
                 encode_pumpswap_buy_ix_data(token_amount, sol_amount, track_volume)
@@ -284,6 +342,8 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
         let quote_mint = protocol_params.quote_mint;
         let pool_base_token_reserves = protocol_params.pool_base_token_reserves;
         let pool_quote_token_reserves = protocol_params.pool_quote_token_reserves;
+        let virtual_quote_reserves = protocol_params.virtual_quote_reserves;
+        protocol_params.effective_quote_reserves()?;
         let pool_base_token_account = protocol_params.pool_base_token_account;
         let pool_quote_token_account = protocol_params.pool_quote_token_account;
         let params_coin_creator_vault_ata = protocol_params.coin_creator_vault_ata;
@@ -305,8 +365,11 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
             return Err(anyhow!("Pool must contain WSOL or USDC"));
         }
 
-        if params.input_amount.is_none() {
-            return Err(anyhow!("Token amount is not set"));
+        if params.input_amount.unwrap_or_default() == 0 {
+            return Err(anyhow!("Token amount must be greater than zero"));
+        }
+        if params.fixed_output_amount == Some(0) {
+            return Err(anyhow!("Fixed output amount cannot be zero"));
         }
 
         // ========================================
@@ -314,12 +377,26 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
         // ========================================
         let quote_is_wsol_or_usdc = quote_mint == crate::constants::WSOL_TOKEN_ACCOUNT
             || quote_mint == crate::constants::USDC_TOKEN_ACCOUNT;
+        if params.fixed_output_amount.is_some() && quote_is_wsol_or_usdc {
+            return Err(anyhow!(
+                "PumpSwap exact-output sell is unsupported when the pool requires a sell instruction"
+            ));
+        }
         let output_stable_mint = if quote_is_wsol_or_usdc { quote_mint } else { base_mint };
         let output_stable_token_program =
             if quote_is_wsol_or_usdc { quote_token_program } else { base_token_program };
+        let input_trade_mint = if quote_is_wsol_or_usdc { base_mint } else { quote_mint };
+        if !request_mint_matches_pool(params.input_mint, input_trade_mint)
+            || !request_mint_matches_pool(params.output_mint, output_stable_mint)
+        {
+            return Err(anyhow!("PumpSwap sell request mints do not match the supplied pool"));
+        }
         let fee_basis_points = protocol_params.fee_basis_points;
 
         let (token_amount, sol_amount) = if let Some(output_amount) = params.fixed_output_amount {
+            if output_amount >= pool_base_token_reserves {
+                return Err(anyhow!("Exact base output must be below the pool base reserve"));
+            }
             (params.input_amount.unwrap(), output_amount)
         } else if quote_is_wsol_or_usdc {
             let result = sell_base_input_internal_with_fees(
@@ -327,9 +404,10 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
                 params.slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE),
                 pool_base_token_reserves,
                 pool_quote_token_reserves,
+                virtual_quote_reserves,
                 &fee_basis_points,
             )
-            .unwrap();
+            .map_err(anyhow::Error::msg)?;
             // base_amount_in, min_quote_amount_out
             (params.input_amount.unwrap(), result.min_quote)
         } else {
@@ -338,9 +416,10 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
                 params.slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE),
                 pool_base_token_reserves,
                 pool_quote_token_reserves,
+                virtual_quote_reserves,
                 &fee_basis_points,
             )
-            .unwrap();
+            .map_err(anyhow::Error::msg)?;
             // max_quote_amount_in, base_amount_out
             (result.max_quote, result.base)
         };
@@ -353,7 +432,7 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
             let recipient = get_protocol_fee_recipient_random();
             (recipient, AccountMeta::new_readonly(recipient, false))
         };
-        let fee_recipient_ata = fee_recipient_ata(fee_recipient, quote_mint);
+        let fee_recipient_ata = fee_recipient_ata(fee_recipient, quote_mint, quote_token_program);
 
         let user_base_token_account =
             crate::common::fast_fn::get_associated_token_address_with_program_id_fast_use_seed(
@@ -416,20 +495,14 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
         }
         accounts.push(accounts::FEE_CONFIG_META);
         accounts.push(accounts::FEE_PROGRAM_META);
-        // Cashback sell: 官方 remainingAccounts = [accumulator 的 quote_mint ATA, accumulator PDA, poolV2]（用 quote_mint 非固定 WSOL）
-        if protocol_params.is_cashback_coin {
-            if let (Some(quote_ata), Some(accumulator)) = (
-                get_user_volume_accumulator_quote_ata(
-                    &params.payer.pubkey(),
-                    &quote_mint,
-                    &quote_token_program,
-                ),
-                get_user_volume_accumulator_pda(&params.payer.pubkey()),
-            ) {
-                accounts.push(AccountMeta::new(quote_ata, false));
-                accounts.push(AccountMeta::new(accumulator, false));
-            }
-        }
+        push_cashback_remaining_accounts(
+            &mut accounts,
+            &params.payer.pubkey(),
+            &quote_mint,
+            &quote_token_program,
+            protocol_params.is_cashback_coin,
+            !quote_is_wsol_or_usdc,
+        )?;
         if protocol_params.coin_creator != Pubkey::default() {
             let pool_v2 = get_pool_v2_pda(&base_mint).ok_or_else(|| {
                 anyhow!("pool_v2 PDA derivation failed for base_mint {}", base_mint)
@@ -439,18 +512,46 @@ impl InstructionBuilder for PumpSwapInstructionBuilder {
         let protocol_extra = get_protocol_extra_fee_recipient_random();
         accounts.push(AccountMeta::new_readonly(protocol_extra, false));
         accounts.push(AccountMeta::new(
-            crate::instruction::utils::pumpswap::fee_recipient_ata(protocol_extra, quote_mint),
+            crate::instruction::utils::pumpswap::fee_recipient_ata(
+                protocol_extra,
+                quote_mint,
+                quote_token_program,
+            ),
             false,
         ));
 
         // 栈数组 + `new_with_bytes`，避免 `data.to_vec()`。
-        let ix_data = if quote_is_wsol_or_usdc {
-            encode_pumpswap_sell_ix_data(token_amount, sol_amount)
+        let track_volume = 1_u8;
+        if quote_is_wsol_or_usdc {
+            let ix_data = encode_pumpswap_sell_ix_data(token_amount, sol_amount);
+            instructions.push(Instruction::new_with_bytes(
+                accounts::AMM_PROGRAM,
+                &ix_data,
+                accounts,
+            ));
+        } else if params.fixed_output_amount.is_some() {
+            let ix_data = encode_pumpswap_buy_ix_data(sol_amount, token_amount, track_volume);
+            instructions.push(Instruction::new_with_bytes(
+                accounts::AMM_PROGRAM,
+                &ix_data,
+                accounts,
+            ));
         } else {
-            encode_pumpswap_buy_two_args(sol_amount, token_amount)
-        };
-
-        instructions.push(Instruction::new_with_bytes(accounts::AMM_PROGRAM, &ix_data, accounts));
+            let min_base_amount_out = crate::utils::calc::common::calculate_with_slippage_sell(
+                sol_amount,
+                params.slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE),
+            );
+            let ix_data = encode_pumpswap_buy_exact_quote_in_ix_data(
+                params.input_amount.unwrap_or(0),
+                min_base_amount_out,
+                track_volume,
+            );
+            instructions.push(Instruction::new_with_bytes(
+                accounts::AMM_PROGRAM,
+                &ix_data,
+                accounts,
+            ));
+        }
 
         if close_wsol_ata {
             push_close_wsol_if_needed(
@@ -535,6 +636,28 @@ mod tests {
             pk(4),
             1_000_000_000,
             2_000_000_000,
+            0,
+            pk(5),
+            accounts::DEFAULT_COIN_CREATOR_VAULT_AUTHORITY,
+            crate::constants::TOKEN_PROGRAM,
+            crate::constants::TOKEN_PROGRAM,
+            accounts::PROTOCOL_FEE_RECIPIENT,
+            Pubkey::default(),
+            false,
+            0,
+        )
+    }
+
+    fn reverse_pumpswap_params() -> PumpSwapParams {
+        PumpSwapParams::new(
+            pk(1),
+            crate::constants::USDC_TOKEN_ACCOUNT,
+            pk(2),
+            pk(3),
+            pk(4),
+            1_000_000_000,
+            2_000_000_000,
+            0,
             pk(5),
             accounts::DEFAULT_COIN_CREATOR_VAULT_AUTHORITY,
             crate::constants::TOKEN_PROGRAM,
@@ -604,16 +727,164 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn pumpswap_sell_fixed_output_uses_min_quote_directly() {
-        let instructions = PumpSwapInstructionBuilder
+    async fn pumpswap_sell_fixed_output_rejects_unsupported_sell_instruction() {
+        let error = PumpSwapInstructionBuilder
             .build_sell_instructions(&swap_params(TradeType::Sell, Some(42)))
             .await
-            .unwrap();
+            .unwrap_err();
+
+        assert_eq!(
+            error.to_string(),
+            "PumpSwap exact-output sell is unsupported when the pool requires a sell instruction"
+        );
+    }
+
+    #[tokio::test]
+    async fn pumpswap_reverse_sell_fixed_output_uses_current_buy_layout() {
+        let mut params = swap_params(TradeType::Sell, Some(42));
+        params.protocol_params = DexParamEnum::PumpSwap(reverse_pumpswap_params());
+        params.output_mint = crate::constants::USDC_TOKEN_ACCOUNT;
+
+        let instructions =
+            PumpSwapInstructionBuilder.build_sell_instructions(&params).await.unwrap();
         let ix = instructions.last().unwrap();
 
-        assert_eq!(&ix.data[..8], crate::instruction::utils::pumpswap::SELL_DISCRIMINATOR);
+        assert_eq!(&ix.data[..8], crate::instruction::utils::pumpswap::BUY_DISCRIMINATOR);
+        assert_eq!(ix.data.len(), 25);
+        assert_eq!(u64::from_le_bytes(ix.data[8..16].try_into().unwrap()), 42);
+        assert_eq!(u64::from_le_bytes(ix.data[16..24].try_into().unwrap()), 100_000);
+        assert_eq!(ix.data[24], 1);
+    }
+
+    #[tokio::test]
+    async fn pumpswap_reverse_sell_exact_input_never_increases_token_spend() {
+        let mut params = swap_params(TradeType::Sell, None);
+        params.protocol_params = DexParamEnum::PumpSwap(reverse_pumpswap_params());
+        params.output_mint = crate::constants::USDC_TOKEN_ACCOUNT;
+
+        let instructions =
+            PumpSwapInstructionBuilder.build_sell_instructions(&params).await.unwrap();
+        let ix = instructions.last().unwrap();
+
+        assert_eq!(
+            &ix.data[..8],
+            crate::instruction::utils::pumpswap::BUY_EXACT_QUOTE_IN_DISCRIMINATOR
+        );
+        assert_eq!(ix.data.len(), 25);
         assert_eq!(u64::from_le_bytes(ix.data[8..16].try_into().unwrap()), 100_000);
-        assert_eq!(u64::from_le_bytes(ix.data[16..24].try_into().unwrap()), 42);
+
+        let quote = crate::utils::calc::pumpswap::buy_quote_input_internal_with_fees(
+            100_000,
+            100,
+            1_000_000_000,
+            2_000_000_000,
+            0,
+            &crate::instruction::utils::pumpswap::PumpSwapFeeBasisPoints::new(25, 5, 0),
+        )
+        .unwrap();
+        let expected_min =
+            crate::utils::calc::common::calculate_with_slippage_sell(quote.base, 100);
+        assert_eq!(u64::from_le_bytes(ix.data[16..24].try_into().unwrap()), expected_min);
+        assert_eq!(ix.data[24], 1);
+    }
+
+    #[tokio::test]
+    async fn pumpswap_buy_cashback_accounts_match_actual_instruction_direction() {
+        let mut params = swap_params(TradeType::Buy, None);
+        let mut protocol_params = pumpswap_params();
+        protocol_params.is_cashback_coin = true;
+        params.protocol_params = DexParamEnum::PumpSwap(protocol_params);
+
+        let instructions =
+            PumpSwapInstructionBuilder.build_buy_instructions(&params).await.unwrap();
+        let ix = instructions.last().unwrap();
+        let expected_ata = get_user_volume_accumulator_quote_ata(
+            &params.payer.pubkey(),
+            &crate::constants::WSOL_TOKEN_ACCOUNT,
+            &crate::constants::TOKEN_PROGRAM,
+        )
+        .unwrap();
+
+        assert_eq!(
+            &ix.data[..8],
+            crate::instruction::utils::pumpswap::BUY_EXACT_QUOTE_IN_DISCRIMINATOR
+        );
+        assert_eq!(ix.accounts[23].pubkey, expected_ata);
+        assert_eq!(ix.data[24], 1);
+    }
+
+    #[tokio::test]
+    async fn pumpswap_reverse_buy_uses_sell_cashback_account_layout() {
+        let mut params = swap_params(TradeType::Buy, None);
+        let mut protocol_params = reverse_pumpswap_params();
+        protocol_params.is_cashback_coin = true;
+        params.protocol_params = DexParamEnum::PumpSwap(protocol_params);
+        params.input_mint = crate::constants::USDC_TOKEN_ACCOUNT;
+
+        let instructions =
+            PumpSwapInstructionBuilder.build_buy_instructions(&params).await.unwrap();
+        let ix = instructions.last().unwrap();
+        let expected_ata = get_user_volume_accumulator_quote_ata(
+            &params.payer.pubkey(),
+            &pk(2),
+            &crate::constants::TOKEN_PROGRAM,
+        )
+        .unwrap();
+        let expected_accumulator = get_user_volume_accumulator_pda(&params.payer.pubkey()).unwrap();
+
+        assert_eq!(&ix.data[..8], crate::instruction::utils::pumpswap::SELL_DISCRIMINATOR);
+        assert_eq!(ix.accounts[21].pubkey, expected_ata);
+        assert_eq!(ix.accounts[22].pubkey, expected_accumulator);
+    }
+
+    #[tokio::test]
+    async fn pumpswap_fee_atas_use_the_quote_token_program() {
+        let quote_token_program = pk(99);
+        let mut params = swap_params(TradeType::Sell, None);
+        let mut protocol_params = reverse_pumpswap_params();
+        protocol_params.quote_token_program = quote_token_program;
+        params.protocol_params = DexParamEnum::PumpSwap(protocol_params);
+        params.output_mint = crate::constants::USDC_TOKEN_ACCOUNT;
+
+        let instructions =
+            PumpSwapInstructionBuilder.build_sell_instructions(&params).await.unwrap();
+        let ix = instructions.last().unwrap();
+        let expected_fee_ata =
+            crate::common::fast_fn::get_associated_token_address_with_program_id_fast(
+                &ix.accounts[9].pubkey,
+                &pk(2),
+                &quote_token_program,
+            );
+        let buyback_recipient_index = ix.accounts.len() - 2;
+        let expected_buyback_ata =
+            crate::common::fast_fn::get_associated_token_address_with_program_id_fast(
+                &ix.accounts[buyback_recipient_index].pubkey,
+                &pk(2),
+                &quote_token_program,
+            );
+
+        assert_eq!(ix.accounts[10].pubkey, expected_fee_ata);
+        assert_eq!(ix.accounts[buyback_recipient_index + 1].pubkey, expected_buyback_ata);
+    }
+
+    #[tokio::test]
+    async fn pumpswap_rejects_request_mints_from_another_pool() {
+        let mut params = swap_params(TradeType::Buy, None);
+        params.output_mint = pk(88);
+
+        let error = PumpSwapInstructionBuilder.build_buy_instructions(&params).await.unwrap_err();
+
+        assert_eq!(error.to_string(), "PumpSwap buy request mints do not match the supplied pool");
+    }
+
+    #[tokio::test]
+    async fn pumpswap_sell_rejects_zero_input() {
+        let mut params = swap_params(TradeType::Sell, None);
+        params.input_amount = Some(0);
+
+        let error = PumpSwapInstructionBuilder.build_sell_instructions(&params).await.unwrap_err();
+
+        assert_eq!(error.to_string(), "Token amount must be greater than zero");
     }
 
     #[tokio::test]
@@ -627,6 +898,7 @@ mod tests {
             pk(4),
             1_000_000_000,
             2_000_000_000,
+            0,
             pk(5),
             accounts::DEFAULT_COIN_CREATOR_VAULT_AUTHORITY,
             crate::constants::TOKEN_PROGRAM,
@@ -653,8 +925,9 @@ mod tests {
         let mut params = swap_params(TradeType::Buy, None);
         params.input_amount = Some(1_000_000);
         params.use_exact_sol_amount = Some(false);
-        params.protocol_params =
-            DexParamEnum::PumpSwap(pumpswap_params().with_fee_basis_points(20, 5, 75));
+        let mut protocol_params = pumpswap_params().with_fee_basis_points(20, 5, 75);
+        protocol_params.virtual_quote_reserves = 500_000_000;
+        params.protocol_params = DexParamEnum::PumpSwap(protocol_params);
 
         let instructions =
             PumpSwapInstructionBuilder.build_buy_instructions(&params).await.unwrap();
@@ -668,9 +941,34 @@ mod tests {
             100,
             1_000_000_000,
             2_000_000_000,
+            500_000_000,
             &crate::instruction::utils::pumpswap::PumpSwapFeeBasisPoints::new(20, 5, 0),
         )
         .unwrap();
         assert_eq!(base_amount_out, expected.base);
     }
+
+    #[tokio::test]
+    async fn pumpswap_sell_prices_with_effective_quote_reserves() {
+        let mut params = swap_params(TradeType::Sell, None);
+        let mut protocol_params = pumpswap_params().with_fee_basis_points(20, 5, 0);
+        protocol_params.virtual_quote_reserves = 500_000_000;
+        params.protocol_params = DexParamEnum::PumpSwap(protocol_params);
+
+        let instructions =
+            PumpSwapInstructionBuilder.build_sell_instructions(&params).await.unwrap();
+        let ix = instructions.last().unwrap();
+        let min_quote_amount_out = u64::from_le_bytes(ix.data[16..24].try_into().unwrap());
+
+        let expected = crate::utils::calc::pumpswap::sell_base_input_internal_with_fees(
+            100_000,
+            100,
+            1_000_000_000,
+            2_000_000_000,
+            500_000_000,
+            &crate::instruction::utils::pumpswap::PumpSwapFeeBasisPoints::new(20, 5, 0),
+        )
+        .unwrap();
+        assert_eq!(min_quote_amount_out, expected.min_quote);
+    }
 }

src/instruction/pumpswap_ix_data.rs

@@ -4,15 +4,6 @@ use crate::instruction::utils::pumpswap::{
     BUY_DISCRIMINATOR, BUY_EXACT_QUOTE_IN_DISCRIMINATOR, SELL_DISCRIMINATOR,
 };
 
-#[inline(always)]
-pub fn encode_pumpswap_buy_two_args(base_amount_out: u64, max_quote_amount_in: u64) -> [u8; 24] {
-    let mut d = [0u8; 24];
-    d[..8].copy_from_slice(&BUY_DISCRIMINATOR);
-    d[8..16].copy_from_slice(&base_amount_out.to_le_bytes());
-    d[16..24].copy_from_slice(&max_quote_amount_in.to_le_bytes());
-    d
-}
-
 #[inline(always)]
 pub fn encode_pumpswap_buy_ix_data(
     base_amount_out: u64,

src/instruction/utils/pumpswap.rs

@@ -2,8 +2,8 @@ use crate::{
     common::{
         spl_associated_token_account::get_associated_token_address_with_program_id, SolanaRpcClient,
     },
-    constants::{TOKEN_PROGRAM, WSOL_TOKEN_ACCOUNT},
-    instruction::utils::pumpswap_types::{pool_decode, Pool},
+    constants::WSOL_TOKEN_ACCOUNT,
+    instruction::utils::pumpswap_types::{pool_decode, Pool, POOL_DISCRIMINATOR},
 };
 use anyhow::anyhow;
 use once_cell::sync::Lazy;
@@ -18,7 +18,7 @@ use std::sync::{
 use std::time::{Duration, Instant};
 use tracing::warn;
 
-// Pool account sizes moved to find_by_base_mint/find_by_quote_mint (POOL_DATA_LEN_SPL, POOL_DATA_LEN_T22)
+// Pool account sizes are handled by find_by_base_mint/find_by_quote_mint.
 
 /// Constants used as seeds for deriving PDAs (Program Derived Addresses)
 pub mod seeds {
@@ -241,6 +241,8 @@ const U8_LEN: usize = 1;
 const BOOL_LEN: usize = 1;
 const GLOBAL_CONFIG_DISCRIMINATOR_LEN: usize = 8;
 const FEE_CONFIG_DISCRIMINATOR_LEN: usize = 8;
+const GLOBAL_CONFIG_DISCRIMINATOR: [u8; 8] = [149, 8, 156, 202, 160, 252, 176, 217];
+const FEE_CONFIG_DISCRIMINATOR: [u8; 8] = [143, 52, 146, 187, 219, 123, 76, 155];
 const FEE_CONFIG_BUMP_LEN: usize = 1;
 const FEE_TIER_LEN: usize = 16 + U64_LEN * 3;
 
@@ -301,6 +303,9 @@ fn read_u32(data: &[u8], offset: usize) -> Option<u32> {
 }
 
 fn decode_global_config(data: &[u8]) -> Option<GlobalConfig> {
+    if data.get(..GLOBAL_CONFIG_DISCRIMINATOR_LEN)? != GLOBAL_CONFIG_DISCRIMINATOR {
+        return None;
+    }
     let mut offset = GLOBAL_CONFIG_DISCRIMINATOR_LEN;
     offset += PUBKEY_LEN; // admin
     let lp_fee_basis_points = read_u64(data, offset)?;
@@ -364,6 +369,9 @@ fn decode_fee_tiers(data: &[u8], offset: &mut usize) -> Option<Vec<PumpSwapFeeTi
 }
 
 pub fn decode_fee_config(data: &[u8]) -> Option<PumpSwapFeeConfig> {
+    if data.get(..FEE_CONFIG_DISCRIMINATOR_LEN)? != FEE_CONFIG_DISCRIMINATOR {
+        return None;
+    }
     let mut offset = FEE_CONFIG_DISCRIMINATOR_LEN;
     offset += FEE_CONFIG_BUMP_LEN;
     offset += PUBKEY_LEN; // admin
@@ -399,6 +407,14 @@ async fn refresh_global_config_once(rpc: &SolanaRpcClient) -> Option<GlobalConfi
         }
     };
 
+    if account.owner != accounts::AMM_PROGRAM {
+        warn!(
+            target: "pumpswap_global_config",
+            owner = %account.owner,
+            "PumpSwap GlobalConfig owner 无效"
+        );
+        return None;
+    }
     let Some(config) = decode_global_config(&account.data) else {
         warn!(
             target: "pumpswap_global_config",
@@ -435,6 +451,14 @@ async fn refresh_fee_config_once(rpc: &SolanaRpcClient) -> Option<PumpSwapFeeCon
         }
     };
 
+    if account.owner != accounts::FEE_PROGRAM {
+        warn!(
+            target: "pumpswap_fee_config",
+            owner = %account.owner,
+            "PumpSwap FeeConfig owner 无效"
+        );
+        return None;
+    }
     let Some(config) = decode_fee_config(&account.data) else {
         warn!(
             target: "pumpswap_fee_config",
@@ -665,22 +689,30 @@ pub(crate) fn coin_creator_vault_authority(coin_creator: Pubkey) -> Pubkey {
     pump_pool_authority
 }
 
-pub(crate) fn coin_creator_vault_ata(coin_creator: Pubkey, quote_mint: Pubkey) -> Pubkey {
+pub(crate) fn coin_creator_vault_ata(
+    coin_creator: Pubkey,
+    quote_mint: Pubkey,
+    quote_token_program: Pubkey,
+) -> Pubkey {
     let creator_vault_authority = coin_creator_vault_authority(coin_creator);
     let associated_token_creator_vault_authority = get_associated_token_address_with_program_id(
         &creator_vault_authority,
         &quote_mint,
-        &TOKEN_PROGRAM,
+        &quote_token_program,
     );
     associated_token_creator_vault_authority
 }
 
-pub(crate) fn fee_recipient_ata(fee_recipient: Pubkey, quote_mint: Pubkey) -> Pubkey {
+pub(crate) fn fee_recipient_ata(
+    fee_recipient: Pubkey,
+    quote_mint: Pubkey,
+    quote_token_program: Pubkey,
+) -> Pubkey {
     let associated_token_fee_recipient =
         crate::common::fast_fn::get_associated_token_address_with_program_id_fast(
             &fee_recipient,
             &quote_mint,
-            &TOKEN_PROGRAM,
+            &quote_token_program,
         );
     associated_token_fee_recipient
 }
@@ -733,19 +765,32 @@ pub async fn fetch_pool(
     pool_address: &Pubkey,
 ) -> Result<Pool, anyhow::Error> {
     let account = rpc.get_account(pool_address).await?;
-    if account.owner != accounts::AMM_PROGRAM {
-        return Err(anyhow!("Account is not owned by PumpSwap program"));
-    }
-    let pool = pool_decode(&account.data[8..]).ok_or_else(|| anyhow!("Failed to decode pool"))?;
-    Ok(pool)
+    decode_pool_account(&account).map_err(anyhow::Error::msg)
 }
 
-/// Known pool account sizes: 252 (SPL Token) and 643 (Token2022)
-const POOL_DATA_LEN_SPL: u64 = 8 + 244;
-const POOL_DATA_LEN_T22: u64 = 643;
+fn decode_pool_account(account: &solana_sdk::account::Account) -> Result<Pool, String> {
+    if account.owner != accounts::AMM_PROGRAM {
+        return Err("Account is not owned by PumpSwap program".to_string());
+    }
+    let discriminator = account
+        .data
+        .get(..8)
+        .ok_or_else(|| "Pool account is shorter than its discriminator".to_string())?;
+    if discriminator != POOL_DISCRIMINATOR {
+        return Err("Account discriminator is not PumpSwap Pool".to_string());
+    }
+    pool_decode(&account.data[8..]).ok_or_else(|| "Failed to decode pool".to_string())
+}
 
-/// Run getProgramAccounts with a Memcmp filter, querying both pool sizes in parallel.
-async fn get_program_accounts_both_sizes(
+/// Known allocated Pool account sizes. Current accounts may be serialized to
+/// exactly 261 bytes or retain a larger historical allocation.
+const POOL_DATA_LEN_LEGACY: u64 = 8 + 244;
+const POOL_DATA_LEN_CURRENT: u64 = 8 + 253;
+const POOL_DATA_LEN_PADDED: u64 = 300;
+const POOL_DATA_LEN_EXTENDED: u64 = 643;
+
+/// Run getProgramAccounts with a Memcmp filter, querying known Pool sizes in parallel.
+async fn get_program_accounts_known_sizes(
     rpc: &SolanaRpcClient,
     memcmp_offset: usize,
     mint: &Pubkey,
@@ -753,6 +798,9 @@ async fn get_program_accounts_both_sizes(
     let make_config = |data_size: u64| solana_rpc_client_api::config::RpcProgramAccountsConfig {
         filters: Some(vec![
             solana_rpc_client_api::filter::RpcFilterType::DataSize(data_size),
+            solana_rpc_client_api::filter::RpcFilterType::Memcmp(
+                solana_client::rpc_filter::Memcmp::new_base58_encoded(0, &POOL_DISCRIMINATOR),
+            ),
             solana_rpc_client_api::filter::RpcFilterType::Memcmp(
                 solana_client::rpc_filter::Memcmp::new_base58_encoded(memcmp_offset, mint.as_ref()),
             ),
@@ -768,12 +816,28 @@ async fn get_program_accounts_both_sizes(
     };
     let program_id = accounts::AMM_PROGRAM;
     #[allow(deprecated)]
-    let (spl_result, t22_result) = tokio::join!(
-        rpc.get_program_accounts_with_config(&program_id, make_config(POOL_DATA_LEN_SPL)),
-        rpc.get_program_accounts_with_config(&program_id, make_config(POOL_DATA_LEN_T22)),
+    let (legacy_result, current_result, padded_result, extended_result) = tokio::join!(
+        rpc.get_program_accounts_with_config(&program_id, make_config(POOL_DATA_LEN_LEGACY)),
+        rpc.get_program_accounts_with_config(&program_id, make_config(POOL_DATA_LEN_CURRENT)),
+        rpc.get_program_accounts_with_config(&program_id, make_config(POOL_DATA_LEN_PADDED)),
+        rpc.get_program_accounts_with_config(&program_id, make_config(POOL_DATA_LEN_EXTENDED)),
     );
-    let mut all = spl_result.unwrap_or_default();
-    all.extend(t22_result.unwrap_or_default());
+    let results = [legacy_result, current_result, padded_result, extended_result];
+    let mut all = Vec::new();
+    let mut errors = Vec::new();
+    for (size, result) in
+        [POOL_DATA_LEN_LEGACY, POOL_DATA_LEN_CURRENT, POOL_DATA_LEN_PADDED, POOL_DATA_LEN_EXTENDED]
+            .into_iter()
+            .zip(results)
+    {
+        match result {
+            Ok(accounts) => all.extend(accounts),
+            Err(error) => errors.push(format!("dataSize={size}: {error}")),
+        }
+    }
+    if !errors.is_empty() {
+        return Err(anyhow!("Incomplete PumpSwap pool query: {}", errors.join("; ")));
+    }
     Ok(all)
 }
 
@@ -782,13 +846,7 @@ fn decode_pool_accounts(
 ) -> Vec<(Pubkey, Pool)> {
     accounts
         .into_iter()
-        .filter_map(|(addr, acc)| {
-            if acc.data.len() > 8 {
-                pool_decode(&acc.data[8..]).map(|pool| (addr, pool))
-            } else {
-                None
-            }
-        })
+        .filter_map(|(addr, acc)| decode_pool_account(&acc).ok().map(|pool| (addr, pool)))
         .collect()
 }
 
@@ -797,7 +855,7 @@ pub async fn find_by_base_mint(
     base_mint: &Pubkey,
 ) -> Result<(Pubkey, Pool), anyhow::Error> {
     // base_mint offset: 8(discriminator) + 1(bump) + 2(index) + 32(creator) = 43
-    let accounts = get_program_accounts_both_sizes(rpc, 43, base_mint).await?;
+    let accounts = get_program_accounts_known_sizes(rpc, 43, base_mint).await?;
     if accounts.is_empty() {
         return Err(anyhow!("No pool found for mint {}", base_mint));
     }
@@ -814,7 +872,7 @@ pub async fn find_by_quote_mint(
     quote_mint: &Pubkey,
 ) -> Result<(Pubkey, Pool), anyhow::Error> {
     // quote_mint offset: 8 + 1 + 2 + 32 + 32 = 75
-    let accounts = get_program_accounts_both_sizes(rpc, 75, quote_mint).await?;
+    let accounts = get_program_accounts_known_sizes(rpc, 75, quote_mint).await?;
     if accounts.is_empty() {
         return Err(anyhow!("No pool found for mint {}", quote_mint));
     }
@@ -878,17 +936,111 @@ pub async fn find_by_mint(
     Err(anyhow!("No pool found for mint {}. diag: {}", mint, diag_str))
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct PoolRpcSnapshot {
+    pub base_reserve: u64,
+    pub quote_reserve: u64,
+    pub base_token_program: Pubkey,
+    pub quote_token_program: Pubkey,
+    pub base_mint_supply: u64,
+}
+
+const TOKEN_ACCOUNT_MINT_END: usize = 32;
+const TOKEN_ACCOUNT_AMOUNT_OFFSET: usize = 64;
+const TOKEN_ACCOUNT_AMOUNT_END: usize = 72;
+const TOKEN_ACCOUNT_STATE_OFFSET: usize = 108;
+const MINT_SUPPLY_OFFSET: usize = 36;
+const MINT_SUPPLY_END: usize = 44;
+const MINT_INITIALIZED_OFFSET: usize = 45;
+
+fn supported_token_program(program: &Pubkey) -> bool {
+    *program == crate::constants::TOKEN_PROGRAM || *program == crate::constants::TOKEN_PROGRAM_2022
+}
+
+fn decode_token_account_amount(
+    account: &solana_sdk::account::Account,
+    expected_mint: &Pubkey,
+) -> Result<(u64, Pubkey), anyhow::Error> {
+    if !supported_token_program(&account.owner) {
+        return Err(anyhow!("Pool vault is not owned by a supported token program"));
+    }
+    let mint = account
+        .data
+        .get(..TOKEN_ACCOUNT_MINT_END)
+        .ok_or_else(|| anyhow!("Pool vault data is too short"))?;
+    if mint != expected_mint.as_ref() {
+        return Err(anyhow!("Pool vault mint does not match Pool account"));
+    }
+    if account.data.get(TOKEN_ACCOUNT_STATE_OFFSET).copied() != Some(1) {
+        return Err(anyhow!("Pool vault is not initialized"));
+    }
+    let amount = account
+        .data
+        .get(TOKEN_ACCOUNT_AMOUNT_OFFSET..TOKEN_ACCOUNT_AMOUNT_END)
+        .and_then(|bytes| bytes.try_into().ok())
+        .map(u64::from_le_bytes)
+        .ok_or_else(|| anyhow!("Pool vault amount is missing"))?;
+    Ok((amount, account.owner))
+}
+
+fn decode_mint_supply(
+    account: &solana_sdk::account::Account,
+    expected_token_program: &Pubkey,
+) -> Result<u64, anyhow::Error> {
+    if account.owner != *expected_token_program {
+        return Err(anyhow!("Base mint and base vault use different token programs"));
+    }
+    if account.data.get(MINT_INITIALIZED_OFFSET).copied() != Some(1) {
+        return Err(anyhow!("Base mint is not initialized"));
+    }
+    account
+        .data
+        .get(MINT_SUPPLY_OFFSET..MINT_SUPPLY_END)
+        .and_then(|bytes| bytes.try_into().ok())
+        .map(u64::from_le_bytes)
+        .ok_or_else(|| anyhow!("Base mint supply is missing"))
+}
+
+pub async fn get_pool_rpc_snapshot(
+    pool: &Pool,
+    rpc: &SolanaRpcClient,
+) -> Result<PoolRpcSnapshot, anyhow::Error> {
+    let addresses = [pool.pool_base_token_account, pool.pool_quote_token_account, pool.base_mint];
+    let accounts = rpc.get_multiple_accounts(&addresses).await?;
+    let base_vault = accounts
+        .first()
+        .and_then(Option::as_ref)
+        .ok_or_else(|| anyhow!("PumpSwap base vault account was not found"))?;
+    let quote_vault = accounts
+        .get(1)
+        .and_then(Option::as_ref)
+        .ok_or_else(|| anyhow!("PumpSwap quote vault account was not found"))?;
+    let base_mint = accounts
+        .get(2)
+        .and_then(Option::as_ref)
+        .ok_or_else(|| anyhow!("PumpSwap base mint account was not found"))?;
+    let (base_reserve, base_token_program) =
+        decode_token_account_amount(base_vault, &pool.base_mint)?;
+    let (quote_reserve, quote_token_program) =
+        decode_token_account_amount(quote_vault, &pool.quote_mint)?;
+    let base_mint_supply = decode_mint_supply(base_mint, &base_token_program)?;
+
+    Ok(PoolRpcSnapshot {
+        base_reserve,
+        quote_reserve,
+        base_token_program,
+        quote_token_program,
+        base_mint_supply,
+    })
+}
+
 pub async fn get_token_balances(
     pool: &Pool,
     rpc: &SolanaRpcClient,
 ) -> Result<(u64, u64), anyhow::Error> {
-    let base_balance = rpc.get_token_account_balance(&pool.pool_base_token_account).await?;
-    let quote_balance = rpc.get_token_account_balance(&pool.pool_quote_token_account).await?;
+    let snapshot = get_pool_rpc_snapshot(pool, rpc).await?;
 
-    let base_amount = base_balance.amount.parse::<u64>().map_err(|e| anyhow!(e))?;
-    let quote_amount = quote_balance.amount.parse::<u64>().map_err(|e| anyhow!(e))?;
-
-    Ok((base_amount, quote_amount))
+    Ok((snapshot.base_reserve, snapshot.quote_reserve))
 }
 
 #[inline]
@@ -902,7 +1054,40 @@ pub fn get_fee_config_pda() -> Option<Pubkey> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use solana_sdk::pubkey::Pubkey;
+    use crate::instruction::utils::pumpswap_types;
+    use solana_sdk::{account::Account, pubkey::Pubkey};
+
+    fn pool_account(virtual_quote_reserves: i128) -> Account {
+        let mut data = Vec::with_capacity(8 + pumpswap_types::POOL_SIZE);
+        data.extend_from_slice(&POOL_DISCRIMINATOR);
+        data.push(7);
+        data.extend_from_slice(&42u16.to_le_bytes());
+        for seed in 1..=6 {
+            data.extend_from_slice(Pubkey::new_from_array([seed; 32]).as_ref());
+        }
+        data.extend_from_slice(&123_456u64.to_le_bytes());
+        data.extend_from_slice(Pubkey::new_from_array([7; 32]).as_ref());
+        data.push(1);
+        data.push(0);
+        data.extend_from_slice(&virtual_quote_reserves.to_le_bytes());
+        Account { data, owner: accounts::AMM_PROGRAM, ..Account::default() }
+    }
+
+    fn token_account(mint: Pubkey, owner: Pubkey, amount: u64) -> Account {
+        let mut data = vec![0; 165];
+        data[..32].copy_from_slice(mint.as_ref());
+        data[TOKEN_ACCOUNT_AMOUNT_OFFSET..TOKEN_ACCOUNT_AMOUNT_END]
+            .copy_from_slice(&amount.to_le_bytes());
+        data[TOKEN_ACCOUNT_STATE_OFFSET] = 1;
+        Account { data, owner, ..Account::default() }
+    }
+
+    fn mint_account(owner: Pubkey, supply: u64) -> Account {
+        let mut data = vec![0; 82];
+        data[MINT_SUPPLY_OFFSET..MINT_SUPPLY_END].copy_from_slice(&supply.to_le_bytes());
+        data[MINT_INITIALIZED_OFFSET] = 1;
+        Account { data, owner, ..Account::default() }
+    }
 
     fn fee_config_fixture() -> PumpSwapFeeConfig {
         PumpSwapFeeConfig {
@@ -929,6 +1114,25 @@ mod tests {
         }
     }
 
+    #[test]
+    fn config_decoders_require_official_account_discriminators() {
+        let global_len = 8 + 32 + 8 + 8 + 1 + 32 * 8 + 8 + 32 + 32 + 32 + 1 + 32 * 7 + 1 + 32 * 8;
+        let mut global_data = vec![0; global_len];
+        global_data[..8].copy_from_slice(&GLOBAL_CONFIG_DISCRIMINATOR);
+        assert!(decode_global_config(&global_data).is_some());
+        global_data[0] ^= 0xff;
+        assert!(decode_global_config(&global_data).is_none());
+
+        let mut fee_data = Vec::with_capacity(8 + 1 + 32 + 24 + 4 + 4);
+        fee_data.extend_from_slice(&FEE_CONFIG_DISCRIMINATOR);
+        fee_data.extend_from_slice(&[0; 1 + 32 + 24]);
+        fee_data.extend_from_slice(&0_u32.to_le_bytes());
+        fee_data.extend_from_slice(&0_u32.to_le_bytes());
+        assert!(decode_fee_config(&fee_data).is_some());
+        fee_data[0] ^= 0xff;
+        assert!(decode_fee_config(&fee_data).is_none());
+    }
+
     #[test]
     fn pumpswap_user_volume_accumulator_pda_deterministic() {
         let user = Pubkey::new_unique();
@@ -986,4 +1190,78 @@ mod tests {
         );
         assert_eq!(fees, PumpSwapFeeBasisPoints::new(20, 5, 75));
     }
+
+    #[test]
+    fn pumpswap_pool_queries_cover_current_serialized_and_padded_sizes() {
+        assert_eq!(POOL_DATA_LEN_LEGACY, 252);
+        assert_eq!(POOL_DATA_LEN_CURRENT, 261);
+        assert_eq!(POOL_DATA_LEN_PADDED, 300);
+        assert_eq!(POOL_DATA_LEN_EXTENDED, 643);
+    }
+
+    #[test]
+    fn pool_account_validation_checks_owner_length_and_discriminator() {
+        let account = pool_account(-123_456);
+        assert_eq!(decode_pool_account(&account).unwrap().virtual_quote_reserves, -123_456);
+
+        let mut wrong_owner = account.clone();
+        wrong_owner.owner = Pubkey::new_unique();
+        assert_eq!(
+            decode_pool_account(&wrong_owner).unwrap_err(),
+            "Account is not owned by PumpSwap program"
+        );
+
+        let mut short = account.clone();
+        short.data.truncate(7);
+        assert_eq!(
+            decode_pool_account(&short).unwrap_err(),
+            "Pool account is shorter than its discriminator"
+        );
+
+        let mut wrong_discriminator = account;
+        wrong_discriminator.data[0] ^= 0xff;
+        assert_eq!(
+            decode_pool_account(&wrong_discriminator).unwrap_err(),
+            "Account discriminator is not PumpSwap Pool"
+        );
+    }
+
+    #[test]
+    fn pool_snapshot_decoders_validate_token_ownership_and_layout() {
+        let mint = Pubkey::new_unique();
+        let token_program = crate::constants::TOKEN_PROGRAM_2022;
+        let vault = token_account(mint, token_program, 987_654_321);
+        assert_eq!(
+            decode_token_account_amount(&vault, &mint).unwrap(),
+            (987_654_321, token_program)
+        );
+        assert_eq!(
+            decode_mint_supply(&mint_account(token_program, 42), &token_program).unwrap(),
+            42
+        );
+
+        let wrong_mint = Pubkey::new_unique();
+        assert_eq!(
+            decode_token_account_amount(&vault, &wrong_mint).unwrap_err().to_string(),
+            "Pool vault mint does not match Pool account"
+        );
+
+        let unsupported = token_account(mint, Pubkey::new_unique(), 1);
+        assert_eq!(
+            decode_token_account_amount(&unsupported, &mint).unwrap_err().to_string(),
+            "Pool vault is not owned by a supported token program"
+        );
+    }
+
+    #[test]
+    fn coin_creator_vault_ata_uses_quote_token_program() {
+        let creator = Pubkey::new_unique();
+        let mint = Pubkey::new_unique();
+        let token_program = crate::constants::TOKEN_PROGRAM_2022;
+        let authority = coin_creator_vault_authority(creator);
+        let expected =
+            get_associated_token_address_with_program_id(&authority, &mint, &token_program);
+
+        assert_eq!(coin_creator_vault_ata(creator, mint, token_program), expected);
+    }
 }

src/instruction/utils/pumpswap_types.rs

@@ -2,6 +2,8 @@ use borsh::BorshDeserialize;
 use serde::{Deserialize, Serialize};
 use solana_sdk::pubkey::Pubkey;
 
+pub const POOL_DISCRIMINATOR: [u8; 8] = [241, 154, 109, 4, 17, 177, 109, 188];
+
 #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
 pub struct Pool {
     pub pool_bump: u8,
@@ -17,16 +19,135 @@ pub struct Pool {
     pub is_mayhem_mode: bool,
     /// Whether this pool's coin has cashback enabled
     pub is_cashback_coin: bool,
-    /// Reserved for future fields (pump-public-docs: pool structure = 244 bytes total)
-    pub _reserved: [u8; 7],
+    /// Virtual quote reserves appended to the Pool account.
+    ///
+    /// Quotes must use `quote_vault_balance + virtual_quote_reserves`.
+    pub virtual_quote_reserves: i128,
 }
 
-/// Borsh 解码用的 Pool 长度。链上池为 244 字节（pump-public-docs Breaking Change），与 POOL_SIZE 一致。
-pub const POOL_SIZE: usize = 244;
+/// Minimum Borsh payload length for the current Pool layout, excluding the
+/// 8-byte Anchor account discriminator.
+pub const POOL_SIZE: usize = 1 + 2 + 32 * 6 + 8 + 32 + 1 + 1 + 16;
+const LEGACY_POOL_FIELDS_SIZE: usize = 1 + 2 + 32 * 6 + 8 + 32 + 1 + 1;
+/// Legacy Pool accounts were allocated with seven trailing padding bytes.
+pub const LEGACY_POOL_SIZE: usize = LEGACY_POOL_FIELDS_SIZE + 7;
+
+#[derive(BorshDeserialize)]
+struct LegacyPool {
+    pool_bump: u8,
+    index: u16,
+    creator: Pubkey,
+    base_mint: Pubkey,
+    quote_mint: Pubkey,
+    lp_mint: Pubkey,
+    pool_base_token_account: Pubkey,
+    pool_quote_token_account: Pubkey,
+    lp_supply: u64,
+    coin_creator: Pubkey,
+    is_mayhem_mode: bool,
+    is_cashback_coin: bool,
+}
+
+impl From<LegacyPool> for Pool {
+    fn from(pool: LegacyPool) -> Self {
+        Self {
+            pool_bump: pool.pool_bump,
+            index: pool.index,
+            creator: pool.creator,
+            base_mint: pool.base_mint,
+            quote_mint: pool.quote_mint,
+            lp_mint: pool.lp_mint,
+            pool_base_token_account: pool.pool_base_token_account,
+            pool_quote_token_account: pool.pool_quote_token_account,
+            lp_supply: pool.lp_supply,
+            coin_creator: pool.coin_creator,
+            is_mayhem_mode: pool.is_mayhem_mode,
+            is_cashback_coin: pool.is_cashback_coin,
+            virtual_quote_reserves: 0,
+        }
+    }
+}
 
 pub fn pool_decode(data: &[u8]) -> Option<Pool> {
-    if data.len() < POOL_SIZE {
-        return None;
+    if data.len() >= POOL_SIZE {
+        return borsh::from_slice::<Pool>(&data[..POOL_SIZE]).ok();
+    }
+
+    if data.len() == LEGACY_POOL_SIZE {
+        return borsh::from_slice::<LegacyPool>(&data[..LEGACY_POOL_FIELDS_SIZE])
+            .ok()
+            .map(Into::into);
+    }
+
+    None
+}
+
+/// Compute the quote reserves used by PumpSwap pricing.
+///
+/// Returns `None` when the signed sum is non-positive or cannot fit in a `u64`.
+#[inline]
+pub fn effective_quote_reserves(
+    quote_vault_balance: u64,
+    virtual_quote_reserves: i128,
+) -> Option<u64> {
+    i128::from(quote_vault_balance)
+        .checked_add(virtual_quote_reserves)
+        .and_then(|reserves| u64::try_from(reserves).ok())
+        .filter(|reserves| *reserves != 0)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn pool_payload(virtual_quote_reserves: i128) -> Vec<u8> {
+        let mut data = Vec::with_capacity(POOL_SIZE);
+        data.push(7);
+        data.extend_from_slice(&42u16.to_le_bytes());
+        for seed in 1..=6 {
+            data.extend_from_slice(Pubkey::new_from_array([seed; 32]).as_ref());
+        }
+        data.extend_from_slice(&123_456u64.to_le_bytes());
+        data.extend_from_slice(Pubkey::new_from_array([7; 32]).as_ref());
+        data.push(1);
+        data.push(0);
+        data.extend_from_slice(&virtual_quote_reserves.to_le_bytes());
+        data
+    }
+
+    #[test]
+    fn decodes_current_pool_virtual_quote_reserves() {
+        let pool = pool_decode(&pool_payload(987_654_321)).unwrap();
+
+        assert_eq!(pool.virtual_quote_reserves, 987_654_321);
+        assert!(pool.is_mayhem_mode);
+        assert!(!pool.is_cashback_coin);
+    }
+
+    #[test]
+    fn decodes_legacy_pool_with_zero_virtual_quote_reserves() {
+        let mut data = pool_payload(0);
+        data.truncate(LEGACY_POOL_FIELDS_SIZE);
+        data.extend_from_slice(&[0; 7]);
+
+        let pool = pool_decode(&data).unwrap();
+        assert_eq!(pool.virtual_quote_reserves, 0);
+    }
+
+    #[test]
+    fn rejects_partial_current_pool_layout() {
+        let current = pool_payload(987_654_321);
+        for len in (LEGACY_POOL_SIZE + 1)..POOL_SIZE {
+            assert!(pool_decode(&current[..len]).is_none(), "accepted body length {len}");
+        }
+    }
+
+    #[test]
+    fn effective_reserves_support_signed_virtual_amounts_and_reject_invalid_sums() {
+        assert_eq!(effective_quote_reserves(1_000, 250), Some(1_250));
+        assert_eq!(effective_quote_reserves(1_000, -250), Some(750));
+        assert_eq!(effective_quote_reserves(1_000, -1_000), None);
+        assert_eq!(effective_quote_reserves(100, -101), None);
+        assert_eq!(effective_quote_reserves(u64::MAX, 1), None);
     }
-    borsh::from_slice::<Pool>(&data[..POOL_SIZE]).ok()
 }

src/trading/core/params/pumpswap.rs

@@ -1,13 +1,9 @@
-use crate::common::spl_associated_token_account::get_associated_token_address_with_program_id;
 use crate::common::SolanaRpcClient;
 use crate::instruction::utils::pumpswap::{
     accounts::MAYHEM_FEE_RECIPIENT as MAYHEM_FEE_RECIPIENT_SWAP, PumpSwapFeeBasisPoints,
 };
 use solana_sdk::pubkey::Pubkey;
 
-const SPL_MINT_SUPPLY_OFFSET: usize = 36;
-const SPL_MINT_SUPPLY_LEN: usize = 8;
-
 /// PumpSwap Protocol Specific Parameters
 ///
 /// Parameters for configuring PumpSwap trading protocol, including liquidity pool information,
@@ -32,8 +28,10 @@ pub struct PumpSwapParams {
     pub pool_quote_token_account: Pubkey,
     /// Base token reserves in the pool
     pub pool_base_token_reserves: u64,
-    /// Quote token reserves in the pool
+    /// Raw quote-vault token balance. Pricing uses this plus [`Self::virtual_quote_reserves`].
     pub pool_quote_token_reserves: u64,
+    /// Signed virtual quote reserves from the PumpSwap Pool account or trade event.
+    pub virtual_quote_reserves: i128,
     /// Coin creator vault ATA
     pub coin_creator_vault_ata: Pubkey,
     /// Coin creator vault authority
@@ -75,6 +73,7 @@ impl PumpSwapParams {
         pool_quote_token_account: Pubkey,
         pool_base_token_reserves: u64,
         pool_quote_token_reserves: u64,
+        virtual_quote_reserves: i128,
         coin_creator_vault_ata: Pubkey,
         coin_creator_vault_authority: Pubkey,
         base_token_program: Pubkey,
@@ -99,6 +98,7 @@ impl PumpSwapParams {
             pool_quote_token_account,
             pool_base_token_reserves,
             pool_quote_token_reserves,
+            virtual_quote_reserves,
             coin_creator_vault_ata,
             coin_creator_vault_authority,
             base_token_program,
@@ -127,6 +127,21 @@ impl PumpSwapParams {
         self
     }
 
+    /// Quote reserves used by PumpSwap pricing and fee-tier selection.
+    pub fn effective_quote_reserves(&self) -> Result<u64, anyhow::Error> {
+        crate::instruction::utils::pumpswap_types::effective_quote_reserves(
+            self.pool_quote_token_reserves,
+            self.virtual_quote_reserves,
+        )
+        .ok_or_else(|| {
+            anyhow::anyhow!(
+                "Invalid PumpSwap effective quote reserves: vault={} virtual={}",
+                self.pool_quote_token_reserves,
+                self.virtual_quote_reserves
+            )
+        })
+    }
+
     pub fn with_fee_basis_points(
         mut self,
         lp_fee_basis_points: u64,
@@ -161,6 +176,7 @@ impl PumpSwapParams {
         pool_quote_token_account: Pubkey,
         pool_base_token_reserves: u64,
         pool_quote_token_reserves: u64,
+        virtual_quote_reserves: i128,
         coin_creator_vault_ata: Pubkey,
         coin_creator_vault_authority: Pubkey,
         base_token_program: Pubkey,
@@ -178,6 +194,7 @@ impl PumpSwapParams {
             pool_quote_token_account,
             pool_base_token_reserves,
             pool_quote_token_reserves,
+            virtual_quote_reserves,
             coin_creator_vault_ata,
             coin_creator_vault_authority,
             base_token_program,
@@ -202,6 +219,7 @@ impl PumpSwapParams {
         pool_quote_token_account: Pubkey,
         pool_base_token_reserves: u64,
         pool_quote_token_reserves: u64,
+        virtual_quote_reserves: i128,
         coin_creator_vault_ata: Pubkey,
         coin_creator_vault_authority: Pubkey,
         base_token_program: Pubkey,
@@ -223,6 +241,7 @@ impl PumpSwapParams {
             pool_quote_token_account,
             pool_base_token_reserves,
             pool_quote_token_reserves,
+            virtual_quote_reserves,
             coin_creator_vault_ata,
             coin_creator_vault_authority,
             base_token_program,
@@ -244,17 +263,9 @@ impl PumpSwapParams {
         rpc: &SolanaRpcClient,
         mint: &Pubkey,
     ) -> Result<Self, anyhow::Error> {
-        if let Ok((pool_address, _)) =
-            crate::instruction::utils::pumpswap::find_by_base_mint(rpc, mint).await
-        {
-            Self::from_pool_address_by_rpc(rpc, &pool_address).await
-        } else if let Ok((pool_address, _)) =
-            crate::instruction::utils::pumpswap::find_by_quote_mint(rpc, mint).await
-        {
-            Self::from_pool_address_by_rpc(rpc, &pool_address).await
-        } else {
-            return Err(anyhow::anyhow!("No pool found for mint"));
-        }
+        let (pool_address, pool) =
+            crate::instruction::utils::pumpswap::find_by_mint(rpc, mint).await?;
+        Self::from_pool_data(rpc, &pool_address, &pool).await
     }
 
     pub async fn from_pool_address_by_rpc(
@@ -275,9 +286,23 @@ impl PumpSwapParams {
         pool_address: &Pubkey,
         pool_data: &crate::instruction::utils::pumpswap_types::Pool,
     ) -> Result<Self, anyhow::Error> {
-        let (pool_base_token_reserves, pool_quote_token_reserves) =
-            crate::instruction::utils::pumpswap::get_token_balances(pool_data, rpc).await?;
-        let base_mint_supply = fetch_mint_supply(rpc, &pool_data.base_mint).await.ok();
+        let snapshot =
+            crate::instruction::utils::pumpswap::get_pool_rpc_snapshot(pool_data, rpc).await?;
+        let pool_base_token_reserves = snapshot.base_reserve;
+        let pool_quote_token_reserves = snapshot.quote_reserve;
+        let effective_quote_token_reserves =
+            crate::instruction::utils::pumpswap_types::effective_quote_reserves(
+                pool_quote_token_reserves,
+                pool_data.virtual_quote_reserves,
+            )
+            .ok_or_else(|| {
+                anyhow::anyhow!(
+                    "Invalid PumpSwap effective quote reserves: vault={} virtual={}",
+                    pool_quote_token_reserves,
+                    pool_data.virtual_quote_reserves
+                )
+            })?;
+        let base_mint_supply = Some(snapshot.base_mint_supply);
         let fee_config = crate::instruction::utils::pumpswap::fetch_fee_config(rpc).await;
         let raw_fee_basis_points = crate::instruction::utils::pumpswap::compute_fee_basis_points(
             fee_config.as_ref(),
@@ -285,7 +310,7 @@ impl PumpSwapParams {
             pool_data.base_mint,
             base_mint_supply,
             pool_base_token_reserves,
-            pool_quote_token_reserves,
+            effective_quote_token_reserves,
         );
         let creator_fee_basis_points = if pool_data.coin_creator == Pubkey::default() {
             0
@@ -296,21 +321,11 @@ impl PumpSwapParams {
         let coin_creator_vault_ata = crate::instruction::utils::pumpswap::coin_creator_vault_ata(
             creator,
             pool_data.quote_mint,
+            snapshot.quote_token_program,
         );
         let coin_creator_vault_authority =
             crate::instruction::utils::pumpswap::coin_creator_vault_authority(creator);
 
-        let base_token_program_ata = get_associated_token_address_with_program_id(
-            pool_address,
-            &pool_data.base_mint,
-            &crate::constants::TOKEN_PROGRAM,
-        );
-        let quote_token_program_ata = get_associated_token_address_with_program_id(
-            pool_address,
-            &pool_data.quote_mint,
-            &crate::constants::TOKEN_PROGRAM,
-        );
-
         Ok(Self {
             pool: *pool_address,
             base_mint: pool_data.base_mint,
@@ -319,19 +334,12 @@ impl PumpSwapParams {
             pool_quote_token_account: pool_data.pool_quote_token_account,
             pool_base_token_reserves,
             pool_quote_token_reserves,
+            virtual_quote_reserves: pool_data.virtual_quote_reserves,
             coin_creator_vault_ata,
             coin_creator_vault_authority,
-            base_token_program: if pool_data.pool_base_token_account == base_token_program_ata {
-                crate::constants::TOKEN_PROGRAM
-            } else {
-                crate::constants::TOKEN_PROGRAM_2022
-            },
+            base_token_program: snapshot.base_token_program,
             is_cashback_coin: pool_data.is_cashback_coin,
-            quote_token_program: if pool_data.pool_quote_token_account == quote_token_program_ata {
-                crate::constants::TOKEN_PROGRAM
-            } else {
-                crate::constants::TOKEN_PROGRAM_2022
-            },
+            quote_token_program: snapshot.quote_token_program,
             is_mayhem_mode: pool_data.is_mayhem_mode,
             pool_creator: pool_data.creator,
             coin_creator: pool_data.coin_creator,
@@ -345,13 +353,3 @@ impl PumpSwapParams {
         })
     }
 }
-
-fn decode_mint_supply(data: &[u8]) -> Option<u64> {
-    let bytes = data.get(SPL_MINT_SUPPLY_OFFSET..SPL_MINT_SUPPLY_OFFSET + SPL_MINT_SUPPLY_LEN)?;
-    Some(u64::from_le_bytes(bytes.try_into().ok()?))
-}
-
-async fn fetch_mint_supply(rpc: &SolanaRpcClient, mint: &Pubkey) -> Result<u64, anyhow::Error> {
-    let account = rpc.get_account(mint).await?;
-    decode_mint_supply(&account.data).ok_or_else(|| anyhow::anyhow!("Failed to decode mint supply"))
-}

src/utils/calc/common.rs

@@ -11,7 +11,18 @@
 /// * fee_basis_points = 100 -> 1% fee
 #[inline(always)]
 pub const fn compute_fee(amount: u128, fee_basis_points: u128) -> u128 {
-    ceil_div(amount * fee_basis_points, 10_000)
+    let whole = match (amount / 10_000).checked_mul(fee_basis_points) {
+        Some(value) => value,
+        None => return u128::MAX,
+    };
+    let remainder_product = match (amount % 10_000).checked_mul(fee_basis_points) {
+        Some(value) => value,
+        None => return u128::MAX,
+    };
+    match whole.checked_add(ceil_div(remainder_product, 10_000)) {
+        Some(value) => value,
+        None => u128::MAX,
+    }
 }
 
 /// Ceiling division implementation
@@ -25,7 +36,12 @@ pub const fn compute_fee(amount: u128, fee_basis_points: u128) -> u128 {
 /// Returns the ceiling result of a/b
 #[inline(always)]
 pub const fn ceil_div(a: u128, b: u128) -> u128 {
-    (a + b - 1) / b
+    let quotient = a / b;
+    if a % b == 0 {
+        quotient
+    } else {
+        quotient + 1
+    }
 }
 
 /// Maximum slippage in basis points (99.99% = 9999 bps)
@@ -55,7 +71,12 @@ pub const fn calculate_with_slippage_buy(amount: u64, basis_points: u64) -> u64
     } else {
         basis_points
     };
-    amount + (amount * bps / 10000)
+    let result = amount as u128 + (amount as u128 * bps as u128 / 10_000);
+    if result > u64::MAX as u128 {
+        u64::MAX
+    } else {
+        result as u64
+    }
 }
 
 /// Calculate sell amount with slippage protection
@@ -75,9 +96,35 @@ pub const fn calculate_with_slippage_sell(amount: u64, basis_points: u64) -> u64
     if amount == 0 {
         return 0;
     }
-    if amount <= basis_points / 10000 {
-        1
+    let bps = if basis_points > MAX_SLIPPAGE_BASIS_POINTS {
+        MAX_SLIPPAGE_BASIS_POINTS
     } else {
-        amount - (amount * basis_points / 10000)
+        basis_points
+    };
+    amount - (amount as u128 * bps as u128 / 10_000) as u64
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ceil_div_handles_u128_max_without_addition_overflow() {
+        assert_eq!(ceil_div(u128::MAX, u128::MAX), 1);
+        assert_eq!(ceil_div(u128::MAX, 2), u128::MAX / 2 + 1);
+    }
+
+    #[test]
+    fn compute_fee_handles_large_amounts_without_multiplication_overflow() {
+        assert_eq!(compute_fee(u128::MAX, 1), ceil_div(u128::MAX, 10_000));
+        assert_eq!(compute_fee(u128::MAX, 10_000), u128::MAX);
+    }
+
+    #[test]
+    fn slippage_helpers_are_deterministic_at_numeric_boundaries() {
+        assert_eq!(calculate_with_slippage_buy(u64::MAX, 100), u64::MAX);
+        assert_eq!(calculate_with_slippage_sell(u64::MAX, 100), 18_262_276_632_972_456_099);
+        assert_eq!(calculate_with_slippage_sell(10_000, u64::MAX), 1);
+        assert_eq!(calculate_with_slippage_sell(1, u64::MAX), 1);
     }
 }

src/utils/calc/pumpfun.rs

@@ -89,7 +89,9 @@ pub fn get_sell_sol_amount_from_token_amount(
     let amount_128 = amount as u128;
 
     // Calculate SOL amount received from selling tokens using constant product formula
-    let numerator = amount_128.checked_mul(virtual_sol_reserves).unwrap_or(0);
+    let Some(numerator) = amount_128.checked_mul(virtual_sol_reserves) else {
+        return u64::MAX;
+    };
     let denominator = virtual_token_reserves.checked_add(amount_128).unwrap_or(1);
 
     let sol_cost = numerator.checked_div(denominator).unwrap_or(0);
@@ -101,5 +103,5 @@ pub fn get_sell_sol_amount_from_token_amount(
     // Calculate transaction fee
     let fee = compute_fee(sol_cost, total_fee_basis_points_128);
 
-    sol_cost.saturating_sub(fee) as u64
+    sol_cost.saturating_sub(fee).min(u64::MAX as u128) as u64
 }

src/utils/calc/pumpswap.rs

@@ -7,16 +7,45 @@ use crate::instruction::utils::pumpswap::accounts::{
 use crate::instruction::utils::pumpswap::PumpSwapFeeBasisPoints;
 use solana_sdk::pubkey::Pubkey;
 
+#[inline]
+fn effective_quote_reserve(
+    quote_reserve: u64,
+    virtual_quote_reserves: i128,
+) -> Result<u64, String> {
+    crate::instruction::utils::pumpswap_types::effective_quote_reserves(
+        quote_reserve,
+        virtual_quote_reserves,
+    )
+    .filter(|reserve| *reserve != 0)
+    .ok_or_else(|| {
+        format!(
+            "Invalid effective quote reserves: raw={quote_reserve}, virtual={virtual_quote_reserves}."
+        )
+    })
+}
+
 /// Creator-side fee bps: fixed coin-creator fee when a creator vault applies, plus optional
 /// cashback fee bps for cashback-enabled coins (see Pump AMM / parser event field).
 #[inline]
 pub(crate) fn creator_side_fee_basis_points(
     coin_creator: &Pubkey,
     cashback_fee_basis_points: u64,
-) -> u64 {
+) -> Result<u64, String> {
     let creator_bps =
         if *coin_creator == Pubkey::default() { 0 } else { COIN_CREATOR_FEE_BASIS_POINTS };
-    creator_bps.saturating_add(cashback_fee_basis_points)
+    creator_bps
+        .checked_add(cashback_fee_basis_points)
+        .ok_or_else(|| "Coin creator fee basis points overflow.".to_string())
+}
+
+#[inline]
+fn checked_u64(value: u128, name: &str) -> Result<u64, String> {
+    u64::try_from(value).map_err(|_| format!("Calculated {name} exceeds u64."))
+}
+
+#[inline]
+fn checked_fee(amount: u64, basis_points: u64, name: &str) -> Result<u64, String> {
+    checked_u64(compute_fee(amount as u128, basis_points as u128), name)
 }
 
 /// Result for buying base tokens with base amount input
@@ -69,7 +98,8 @@ pub struct SellQuoteInputResult {
 /// * `base` - Amount of base tokens to buy
 /// * `slippage_basis_points` - Slippage tolerance in basis points (100 = 1%)
 /// * `base_reserve` - Base token reserves in the pool
-/// * `quote_reserve` - Quote token reserves in the pool
+/// * `quote_reserve` - Raw quote-vault balance
+/// * `virtual_quote_reserves` - Signed virtual quote reserves from the same pool snapshot
 /// * `coin_creator` - Token creator address
 /// * `cashback_fee_basis_points` - Extra fee bps for cashback coins (from on-chain / events); use `0` if unknown
 ///
@@ -80,6 +110,7 @@ pub fn buy_base_input_internal(
     slippage_basis_points: u64,
     base_reserve: u64,
     quote_reserve: u64,
+    virtual_quote_reserves: i128,
     coin_creator: &Pubkey,
     cashback_fee_basis_points: u64,
 ) -> Result<BuyBaseInputResult, String> {
@@ -88,10 +119,11 @@ pub fn buy_base_input_internal(
         slippage_basis_points,
         base_reserve,
         quote_reserve,
+        virtual_quote_reserves,
         &PumpSwapFeeBasisPoints::new(
             LP_FEE_BASIS_POINTS,
             PROTOCOL_FEE_BASIS_POINTS,
-            creator_side_fee_basis_points(coin_creator, cashback_fee_basis_points),
+            creator_side_fee_basis_points(coin_creator, cashback_fee_basis_points)?,
         ),
     )
 }
@@ -101,36 +133,42 @@ pub fn buy_base_input_internal_with_fees(
     slippage_basis_points: u64,
     base_reserve: u64,
     quote_reserve: u64,
+    virtual_quote_reserves: i128,
     fee_basis_points: &PumpSwapFeeBasisPoints,
 ) -> Result<BuyBaseInputResult, String> {
     if base_reserve == 0 || quote_reserve == 0 {
         return Err("Invalid input: 'baseReserve' or 'quoteReserve' cannot be zero.".to_string());
     }
+    let effective_quote_reserve = effective_quote_reserve(quote_reserve, virtual_quote_reserves)?;
     if base > base_reserve {
         return Err("Cannot buy more base tokens than the pool reserves.".to_string());
     }
 
     // Calculate required quote amount using constant product formula
-    let numerator = (quote_reserve as u128) * (base as u128);
+    let numerator = (effective_quote_reserve as u128) * (base as u128);
     let denominator = base_reserve - base;
 
     if denominator == 0 {
         return Err("Pool would be depleted; denominator is zero.".to_string());
     }
 
-    let quote_amount_in = ceil_div(numerator, denominator as u128) as u64;
+    let quote_amount_in =
+        checked_u64(ceil_div(numerator, denominator as u128), "raw quote amount")?;
 
     // Calculate fees
-    let lp_fee =
-        compute_fee(quote_amount_in as u128, fee_basis_points.lp_fee_basis_points as u128) as u64;
+    let lp_fee = checked_fee(quote_amount_in, fee_basis_points.lp_fee_basis_points, "LP fee")?;
     let protocol_fee =
-        compute_fee(quote_amount_in as u128, fee_basis_points.protocol_fee_basis_points as u128)
-            as u64;
-    let coin_creator_fee = compute_fee(
-        quote_amount_in as u128,
-        fee_basis_points.coin_creator_fee_basis_points as u128,
-    ) as u64;
-    let total_quote = quote_amount_in + lp_fee + protocol_fee + coin_creator_fee;
+        checked_fee(quote_amount_in, fee_basis_points.protocol_fee_basis_points, "protocol fee")?;
+    let coin_creator_fee = checked_fee(
+        quote_amount_in,
+        fee_basis_points.coin_creator_fee_basis_points,
+        "coin creator fee",
+    )?;
+    let total_quote = quote_amount_in
+        .checked_add(lp_fee)
+        .and_then(|amount| amount.checked_add(protocol_fee))
+        .and_then(|amount| amount.checked_add(coin_creator_fee))
+        .ok_or_else(|| "Total quote amount exceeds u64.".to_string())?;
 
     // Calculate max quote with slippage
     let max_quote = calculate_with_slippage_buy(total_quote, slippage_basis_points);
@@ -148,7 +186,8 @@ pub fn buy_base_input_internal_with_fees(
 /// * `quote` - Amount of quote tokens to spend
 /// * `slippage_basis_points` - Slippage tolerance in basis points (100 = 1%)
 /// * `base_reserve` - Base token reserves in the pool
-/// * `quote_reserve` - Quote token reserves in the pool
+/// * `quote_reserve` - Raw quote-vault balance
+/// * `virtual_quote_reserves` - Signed virtual quote reserves from the same pool snapshot
 /// * `coin_creator` - Token creator address
 /// * `cashback_fee_basis_points` - Extra fee bps for cashback coins; use `0` if unknown
 ///
@@ -159,6 +198,7 @@ pub fn buy_quote_input_internal(
     slippage_basis_points: u64,
     base_reserve: u64,
     quote_reserve: u64,
+    virtual_quote_reserves: i128,
     coin_creator: &Pubkey,
     cashback_fee_basis_points: u64,
 ) -> Result<BuyQuoteInputResult, String> {
@@ -167,10 +207,11 @@ pub fn buy_quote_input_internal(
         slippage_basis_points,
         base_reserve,
         quote_reserve,
+        virtual_quote_reserves,
         &PumpSwapFeeBasisPoints::new(
             LP_FEE_BASIS_POINTS,
             PROTOCOL_FEE_BASIS_POINTS,
-            creator_side_fee_basis_points(coin_creator, cashback_fee_basis_points),
+            creator_side_fee_basis_points(coin_creator, cashback_fee_basis_points)?,
         ),
     )
 }
@@ -180,18 +221,23 @@ pub fn buy_quote_input_internal_with_fees(
     slippage_basis_points: u64,
     base_reserve: u64,
     quote_reserve: u64,
+    virtual_quote_reserves: i128,
     fee_basis_points: &PumpSwapFeeBasisPoints,
 ) -> Result<BuyQuoteInputResult, String> {
     if base_reserve == 0 || quote_reserve == 0 {
         return Err("Invalid input: 'baseReserve' or 'quoteReserve' cannot be zero.".to_string());
     }
+    let effective_quote_reserve = effective_quote_reserve(quote_reserve, virtual_quote_reserves)?;
 
     // Calculate total fee basis points
     let total_fee_bps = fee_basis_points
         .lp_fee_basis_points
-        .saturating_add(fee_basis_points.protocol_fee_basis_points)
-        .saturating_add(fee_basis_points.coin_creator_fee_basis_points);
-    let denominator = 10_000 + total_fee_bps;
+        .checked_add(fee_basis_points.protocol_fee_basis_points)
+        .and_then(|fees| fees.checked_add(fee_basis_points.coin_creator_fee_basis_points))
+        .ok_or_else(|| "Fee basis points overflow.".to_string())?;
+    let denominator = 10_000_u64
+        .checked_add(total_fee_bps)
+        .ok_or_else(|| "Fee denominator overflow.".to_string())?;
 
     // Calculate effective quote amount after fees
     let mut effective_quote = (quote as u128 * 10_000) / denominator as u128;
@@ -200,28 +246,36 @@ pub fn buy_quote_input_internal_with_fees(
         compute_fee(effective_quote, fee_basis_points.protocol_fee_basis_points as u128);
     let coin_creator_fee =
         compute_fee(effective_quote, fee_basis_points.coin_creator_fee_basis_points as u128);
-    let total_with_fees = effective_quote + lp_fee + protocol_fee + coin_creator_fee;
+    let total_with_fees = effective_quote
+        .checked_add(lp_fee)
+        .and_then(|amount| amount.checked_add(protocol_fee))
+        .and_then(|amount| amount.checked_add(coin_creator_fee))
+        .ok_or_else(|| "Total quote amount exceeds u128.".to_string())?;
     if total_with_fees > quote as u128 {
-        effective_quote = effective_quote.saturating_sub(total_with_fees - quote as u128);
+        effective_quote = effective_quote
+            .checked_sub(total_with_fees - quote as u128)
+            .ok_or_else(|| "Quote input is too small to cover fees.".to_string())?;
     }
-    let input_amount = effective_quote.saturating_sub(1);
+    let input_amount = effective_quote
+        .checked_sub(1)
+        .ok_or_else(|| "Quote input is too small after fees.".to_string())?;
 
     // Calculate base amount out using constant product formula
     let numerator = (base_reserve as u128) * input_amount;
-    let denominator_effective = (quote_reserve as u128) + input_amount;
+    let denominator_effective = (effective_quote_reserve as u128) + input_amount;
 
     if denominator_effective == 0 {
         return Err("Pool would be depleted; denominator is zero.".to_string());
     }
 
-    let base_amount_out = (numerator / denominator_effective) as u64;
+    let base_amount_out = checked_u64(numerator / denominator_effective, "base amount")?;
 
     // Calculate max quote with slippage
     let max_quote = calculate_with_slippage_buy(quote, slippage_basis_points);
 
     Ok(BuyQuoteInputResult {
         base: base_amount_out,
-        internal_quote_without_fees: effective_quote as u64,
+        internal_quote_without_fees: checked_u64(effective_quote, "effective quote amount")?,
         max_quote,
     })
 }
@@ -232,7 +286,8 @@ pub fn buy_quote_input_internal_with_fees(
 /// * `base` - Amount of base tokens to sell
 /// * `slippage_basis_points` - Slippage tolerance in basis points (100 = 1%)
 /// * `base_reserve` - Base token reserves in the pool
-/// * `quote_reserve` - Quote token reserves in the pool
+/// * `quote_reserve` - Raw quote-vault balance
+/// * `virtual_quote_reserves` - Signed virtual quote reserves from the same pool snapshot
 /// * `coin_creator` - Token creator address
 /// * `cashback_fee_basis_points` - Extra fee bps for cashback coins; use `0` if unknown
 ///
@@ -243,6 +298,7 @@ pub fn sell_base_input_internal(
     slippage_basis_points: u64,
     base_reserve: u64,
     quote_reserve: u64,
+    virtual_quote_reserves: i128,
     coin_creator: &Pubkey,
     cashback_fee_basis_points: u64,
 ) -> Result<SellBaseInputResult, String> {
@@ -251,10 +307,11 @@ pub fn sell_base_input_internal(
         slippage_basis_points,
         base_reserve,
         quote_reserve,
+        virtual_quote_reserves,
         &PumpSwapFeeBasisPoints::new(
             LP_FEE_BASIS_POINTS,
             PROTOCOL_FEE_BASIS_POINTS,
-            creator_side_fee_basis_points(coin_creator, cashback_fee_basis_points),
+            creator_side_fee_basis_points(coin_creator, cashback_fee_basis_points)?,
         ),
     )
 }
@@ -264,32 +321,43 @@ pub fn sell_base_input_internal_with_fees(
     slippage_basis_points: u64,
     base_reserve: u64,
     quote_reserve: u64,
+    virtual_quote_reserves: i128,
     fee_basis_points: &PumpSwapFeeBasisPoints,
 ) -> Result<SellBaseInputResult, String> {
     if base_reserve == 0 || quote_reserve == 0 {
         return Err("Invalid input: 'baseReserve' or 'quoteReserve' cannot be zero.".to_string());
     }
+    let effective_quote_reserve = effective_quote_reserve(quote_reserve, virtual_quote_reserves)?;
 
     // Calculate quote amount out using constant product formula
-    let quote_amount_out = ((quote_reserve as u128) * (base as u128)
-        / ((base_reserve as u128) + (base as u128))) as u64;
+    let quote_amount_out = checked_u64(
+        (effective_quote_reserve as u128) * (base as u128)
+            / ((base_reserve as u128) + (base as u128)),
+        "raw quote amount",
+    )?;
 
     // Calculate fees
-    let lp_fee =
-        compute_fee(quote_amount_out as u128, fee_basis_points.lp_fee_basis_points as u128) as u64;
+    let lp_fee = checked_fee(quote_amount_out, fee_basis_points.lp_fee_basis_points, "LP fee")?;
     let protocol_fee =
-        compute_fee(quote_amount_out as u128, fee_basis_points.protocol_fee_basis_points as u128)
-            as u64;
-    let coin_creator_fee = compute_fee(
-        quote_amount_out as u128,
-        fee_basis_points.coin_creator_fee_basis_points as u128,
-    ) as u64;
+        checked_fee(quote_amount_out, fee_basis_points.protocol_fee_basis_points, "protocol fee")?;
+    let coin_creator_fee = checked_fee(
+        quote_amount_out,
+        fee_basis_points.coin_creator_fee_basis_points,
+        "coin creator fee",
+    )?;
 
     // Calculate final quote after fees
-    let total_fees = lp_fee + protocol_fee + coin_creator_fee;
+    let total_fees = lp_fee
+        .checked_add(protocol_fee)
+        .and_then(|fees| fees.checked_add(coin_creator_fee))
+        .ok_or_else(|| "Total fees exceed u64.".to_string())?;
     if total_fees > quote_amount_out {
         return Err("Fees exceed total output; final quote is negative.".to_string());
     }
+    let quote_vault_outflow = quote_amount_out - lp_fee;
+    if quote_vault_outflow > quote_reserve {
+        return Err("Insufficient real quote reserves to cover the sell output.".to_string());
+    }
     let final_quote = quote_amount_out - total_fees;
 
     // Calculate min quote with slippage
@@ -310,12 +378,22 @@ fn calculate_quote_amount_out(
     lp_fee_basis_points: u64,
     protocol_fee_basis_points: u64,
     coin_creator_fee_basis_points: u64,
-) -> u64 {
-    let total_fee_basis_points =
-        lp_fee_basis_points + protocol_fee_basis_points + coin_creator_fee_basis_points;
-    let denominator = MAX_FEE_BASIS_POINTS - total_fee_basis_points;
-    ceil_div((user_quote_amount_out as u128) * (MAX_FEE_BASIS_POINTS as u128), denominator as u128)
-        as u64
+) -> Result<u64, String> {
+    let total_fee_basis_points = lp_fee_basis_points
+        .checked_add(protocol_fee_basis_points)
+        .and_then(|fees| fees.checked_add(coin_creator_fee_basis_points))
+        .ok_or_else(|| "Fee basis points overflow.".to_string())?;
+    let denominator = MAX_FEE_BASIS_POINTS
+        .checked_sub(total_fee_basis_points)
+        .ok_or_else(|| "Total fee basis points must be less than 10,000.".to_string())?;
+    if denominator == 0 {
+        return Err("Total fee basis points must be less than 10,000.".to_string());
+    }
+    let raw_quote = ceil_div(
+        (user_quote_amount_out as u128) * (MAX_FEE_BASIS_POINTS as u128),
+        denominator as u128,
+    );
+    u64::try_from(raw_quote).map_err(|_| "Calculated quote amount exceeds u64.".to_string())
 }
 
 /// Calculate base tokens needed to receive a specific amount of quote tokens
@@ -324,7 +402,8 @@ fn calculate_quote_amount_out(
 /// * `quote` - Desired amount of quote tokens to receive
 /// * `slippage_basis_points` - Slippage tolerance in basis points (100 = 1%)
 /// * `base_reserve` - Base token reserves in the pool
-/// * `quote_reserve` - Quote token reserves in the pool
+/// * `quote_reserve` - Raw quote-vault balance
+/// * `virtual_quote_reserves` - Signed virtual quote reserves from the same pool snapshot
 /// * `coin_creator` - Token creator address
 /// * `cashback_fee_basis_points` - Extra fee bps for cashback coins; use `0` if unknown
 ///
@@ -335,6 +414,7 @@ pub fn sell_quote_input_internal(
     slippage_basis_points: u64,
     base_reserve: u64,
     quote_reserve: u64,
+    virtual_quote_reserves: i128,
     coin_creator: &Pubkey,
     cashback_fee_basis_points: u64,
 ) -> Result<SellQuoteInputResult, String> {
@@ -343,10 +423,11 @@ pub fn sell_quote_input_internal(
         slippage_basis_points,
         base_reserve,
         quote_reserve,
+        virtual_quote_reserves,
         &PumpSwapFeeBasisPoints::new(
             LP_FEE_BASIS_POINTS,
             PROTOCOL_FEE_BASIS_POINTS,
-            creator_side_fee_basis_points(coin_creator, cashback_fee_basis_points),
+            creator_side_fee_basis_points(coin_creator, cashback_fee_basis_points)?,
         ),
     )
 }
@@ -356,6 +437,7 @@ pub fn sell_quote_input_internal_with_fees(
     slippage_basis_points: u64,
     base_reserve: u64,
     quote_reserve: u64,
+    virtual_quote_reserves: i128,
     fee_basis_points: &PumpSwapFeeBasisPoints,
 ) -> Result<SellQuoteInputResult, String> {
     if base_reserve == 0 || quote_reserve == 0 {
@@ -364,6 +446,7 @@ pub fn sell_quote_input_internal_with_fees(
     if quote > quote_reserve {
         return Err("Cannot receive more quote tokens than the pool quote reserves.".to_string());
     }
+    let effective_quote_reserve = effective_quote_reserve(quote_reserve, virtual_quote_reserves)?;
 
     // Calculate raw quote amount including fees
     let raw_quote = calculate_quote_amount_out(
@@ -371,19 +454,232 @@ pub fn sell_quote_input_internal_with_fees(
         fee_basis_points.lp_fee_basis_points,
         fee_basis_points.protocol_fee_basis_points,
         fee_basis_points.coin_creator_fee_basis_points,
-    );
+    )?;
+
+    let lp_fee = checked_fee(raw_quote, fee_basis_points.lp_fee_basis_points, "LP fee")?;
+    let quote_vault_outflow = raw_quote
+        .checked_sub(lp_fee)
+        .ok_or_else(|| "LP fee exceeds raw quote output.".to_string())?;
+    if quote_vault_outflow > quote_reserve {
+        return Err("Insufficient real quote reserves to cover the sell output.".to_string());
+    }
 
     // Calculate base amount needed using inverse constant product formula
-    if raw_quote >= quote_reserve {
+    if raw_quote >= effective_quote_reserve {
         return Err("Invalid input: Desired quote amount exceeds available reserve.".to_string());
     }
 
-    let base_amount_in =
-        ceil_div((base_reserve as u128) * (raw_quote as u128), (quote_reserve - raw_quote) as u128)
-            as u64;
+    let base_amount_in = checked_u64(
+        ceil_div(
+            (base_reserve as u128) * (raw_quote as u128),
+            (effective_quote_reserve - raw_quote) as u128,
+        ),
+        "base amount",
+    )?;
 
     // Calculate min quote with slippage
     let min_quote = calculate_with_slippage_sell(quote, slippage_basis_points);
 
     Ok(SellQuoteInputResult { internal_raw_quote: raw_quote, base: base_amount_in, min_quote })
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn fees() -> PumpSwapFeeBasisPoints {
+        PumpSwapFeeBasisPoints::new(20, 5, 0)
+    }
+
+    #[test]
+    fn buy_uses_effective_quote_reserves() {
+        let result =
+            buy_quote_input_internal_with_fees(10_000, 100, 1_000_000, 1_000_000, 500_000, &fees())
+                .unwrap();
+        let without_virtual =
+            buy_quote_input_internal_with_fees(10_000, 100, 1_000_000, 1_000_000, 0, &fees())
+                .unwrap();
+
+        assert!(result.base < without_virtual.base);
+    }
+
+    #[test]
+    fn sell_rejects_output_not_covered_by_real_quote_vault() {
+        let error = sell_base_input_internal_with_fees(
+            1_000_000,
+            100,
+            1_000_000,
+            1_000,
+            1_000_000,
+            &fees(),
+        )
+        .unwrap_err();
+
+        assert_eq!(error, "Insufficient real quote reserves to cover the sell output.");
+    }
+
+    #[test]
+    fn exact_quote_sell_uses_effective_reserve_for_denominator() {
+        let result =
+            sell_quote_input_internal_with_fees(500, 100, 1_000_000, 1_000, 1_000_000, &fees())
+                .unwrap();
+
+        assert!(result.base < 1_000);
+    }
+
+    #[test]
+    fn exact_quote_sell_rejects_output_above_real_quote_vault() {
+        let error =
+            sell_quote_input_internal_with_fees(1_001, 100, 1_000_000, 1_000, 1_000_000, &fees())
+                .unwrap_err();
+
+        assert_eq!(error, "Cannot receive more quote tokens than the pool quote reserves.");
+    }
+
+    #[test]
+    fn negative_virtual_reserves_are_applied() {
+        let result = buy_quote_input_internal_with_fees(
+            10_000,
+            100,
+            1_000_000,
+            1_000_000,
+            -500_000,
+            &fees(),
+        )
+        .unwrap();
+        let without_virtual =
+            buy_quote_input_internal_with_fees(10_000, 100, 1_000_000, 1_000_000, 0, &fees())
+                .unwrap();
+
+        assert!(result.base > without_virtual.base);
+    }
+
+    #[test]
+    fn zero_effective_quote_reserves_are_rejected() {
+        let error = buy_quote_input_internal_with_fees(
+            10_000,
+            100,
+            1_000_000,
+            1_000_000,
+            -1_000_000,
+            &fees(),
+        )
+        .unwrap_err();
+
+        assert_eq!(error, "Invalid effective quote reserves: raw=1000000, virtual=-1000000.");
+    }
+
+    #[test]
+    fn quote_modes_match_official_integer_formulas() {
+        let fees = PumpSwapFeeBasisPoints::new(20, 5, 30);
+        let base_reserve = 800_000_000_000_000;
+        let quote_reserve = 100_000_000_000;
+        let virtual_quote_reserves = 5_000_000_000;
+        let slippage_basis_points = 125;
+
+        let buy_base = buy_base_input_internal_with_fees(
+            123_456_789_000,
+            slippage_basis_points,
+            base_reserve,
+            quote_reserve,
+            virtual_quote_reserves,
+            &fees,
+        )
+        .unwrap();
+        assert_eq!(buy_base.internal_quote_amount, 16_206_205);
+        assert_eq!(buy_base.ui_quote, 16_295_341);
+        assert_eq!(buy_base.max_quote, 16_499_032);
+
+        let buy_quote = buy_quote_input_internal_with_fees(
+            1_500_000_000,
+            slippage_basis_points,
+            base_reserve,
+            quote_reserve,
+            virtual_quote_reserves,
+            &fees,
+        )
+        .unwrap();
+        assert_eq!(buy_quote.internal_quote_without_fees, 1_491_795_125);
+        assert_eq!(buy_quote.base, 11_206_836_149_304);
+        assert_eq!(buy_quote.max_quote, 1_518_750_000);
+
+        let sell_base = sell_base_input_internal_with_fees(
+            123_456_789_000,
+            slippage_basis_points,
+            base_reserve,
+            quote_reserve,
+            virtual_quote_reserves,
+            &fees,
+        )
+        .unwrap();
+        assert_eq!(sell_base.internal_quote_amount_out, 16_201_203);
+        assert_eq!(sell_base.ui_quote, 16_112_095);
+        assert_eq!(sell_base.min_quote, 15_910_694);
+
+        let sell_quote = sell_quote_input_internal_with_fees(
+            500_000_000,
+            slippage_basis_points,
+            base_reserve,
+            quote_reserve,
+            virtual_quote_reserves,
+            &fees,
+        )
+        .unwrap();
+        assert_eq!(sell_quote.internal_raw_quote, 502_765_209);
+        assert_eq!(sell_quote.base, 3_849_022_110_532);
+        assert_eq!(sell_quote.min_quote, 493_750_000);
+    }
+
+    #[test]
+    fn oversized_quote_results_return_errors_instead_of_truncating() {
+        let no_fees = PumpSwapFeeBasisPoints::new(0, 0, 0);
+
+        let buy_error =
+            buy_base_input_internal_with_fees(u64::MAX - 1, 0, u64::MAX, u64::MAX, 0, &no_fees)
+                .unwrap_err();
+        assert_eq!(buy_error, "Calculated raw quote amount exceeds u64.");
+
+        let sell_error =
+            sell_quote_input_internal_with_fees(u64::MAX - 1, 0, u64::MAX, u64::MAX, 0, &no_fees)
+                .unwrap_err();
+        assert_eq!(sell_error, "Calculated base amount exceeds u64.");
+    }
+
+    #[test]
+    fn invalid_fee_boundaries_return_errors() {
+        let overflowing_fees = PumpSwapFeeBasisPoints::new(u64::MAX, 1, 0);
+        let error = buy_quote_input_internal_with_fees(
+            10_000,
+            0,
+            1_000_000,
+            1_000_000,
+            0,
+            &overflowing_fees,
+        )
+        .unwrap_err();
+        assert_eq!(error, "Fee basis points overflow.");
+
+        let oversized_fee = PumpSwapFeeBasisPoints::new(u64::MAX, 0, 0);
+        let error = sell_base_input_internal_with_fees(
+            1_000_000,
+            0,
+            1_000_000,
+            1_000_000,
+            0,
+            &oversized_fee,
+        )
+        .unwrap_err();
+        assert_eq!(error, "Calculated LP fee exceeds u64.");
+
+        let error = creator_side_fee_basis_points(&Pubkey::new_unique(), u64::MAX).unwrap_err();
+        assert_eq!(error, "Coin creator fee basis points overflow.");
+    }
+
+    #[test]
+    fn buy_quote_rejects_amount_too_small_after_fees() {
+        let error =
+            buy_quote_input_internal_with_fees(1, 0, 1_000_000, 1_000_000, 0, &fees()).unwrap_err();
+
+        assert_eq!(error, "Quote input is too small after fees.");
+    }
+}