Release v3.6.5: SWQOS core affinity and recommended sender thread indices

- Add TradeConfig::with_swqos_cores_from_end(bool) to use last N CPU cores for SWQOS, reducing contention with main thread and default tokio workers.
- Add recommended_sender_thread_core_indices(swqos_count) to get the same last-N core indices for with_dedicated_sender_threads (recommended combo for lower latency).
- Document core affinity and latency in async_executor and with_dedicated_sender_threads.

Made-with: Cursor

Cargo.toml

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

README.md

@@ -90,14 +90,14 @@ Add the dependency to your `Cargo.toml`:
 
 ```toml
 # Add to your Cargo.toml
-sol-trade-sdk = { path = "./sol-trade-sdk", version = "3.6.3" }
+sol-trade-sdk = { path = "./sol-trade-sdk", version = "3.6.4" }
 ```
 
 ### Use crates.io
 
 ```toml
 # Add to your Cargo.toml
-sol-trade-sdk = "3.6.3"
+sol-trade-sdk = "3.6.4"
 ```
 
 ## 🛠️ Usage Examples

README_CN.md

@@ -90,14 +90,14 @@ git clone https://github.com/0xfnzero/sol-trade-sdk
 
 ```toml
 # 添加到您的 Cargo.toml
-sol-trade-sdk = { path = "./sol-trade-sdk", version = "3.6.3" }
+sol-trade-sdk = { path = "./sol-trade-sdk", version = "3.6.4" }
 ```
 
 ### 使用 crates.io
 
 ```toml
 # 添加到您的 Cargo.toml
-sol-trade-sdk = "3.6.3"
+sol-trade-sdk = "3.6.4"
 ```
 
 ## 🛠️ 使用示例

RELEASE_v3.6.3.md

@@ -1,14 +0,0 @@
-# Release v3.6.3
-
-## Changes from v3.6.2
-
-### Parallel multi-SWQoS submit
-
-- **Transaction builder pool**: Introduced `PARALLEL_SENDER_COUNT` (18) and ensured pool prefill is at least 18, so that when using dedicated sender threads all channels can acquire a builder without waiting or allocating. Prefill is now 64 with a guaranteed minimum of 18.
-- **Async executor**: Documented that builder pool prefill must match the dedicated sender thread count so multi-channel submit never serializes on `build_transaction`.
-- **Executor logging**: Submit timings are no longer sorted before printing (avoids any extra work on the hot path). Log order reflects completion order (first-completed first); the last line is the slowest channel in that batch.
-
-### Other
-
-- Added `docs/ASYNC_EXECUTOR_REVIEW.md`.
-- Minor updates in types, lib, params, and middleware example.

RELEASE_v3.6.4.md

@@ -0,0 +1,8 @@
+# Release v3.6.4
+
+## Changes from v3.6.3
+
+- **Examples**: All workspace examples are verified to build successfully (`cargo build --workspace`).
+- **Docs**: Version references in README.md and README_CN.md updated to 3.6.4.
+
+No API or behavior changes in this release.

docs/ASYNC_EXECUTOR_REVIEW.md

@@ -1,24 +0,0 @@
-# async_executor 逻辑与超低延迟 / 无锁竞争 审查
-
-## 1. 逻辑正确性
-
-- **execute_parallel 流程**：预计算 task_configs → 建一次 shared + collector → 选 queue/notify（专属池或 tokio 池）→ 填 tip_cache、组 SwqosJob、全部 push → notify_waiters → 根据 wait_transaction_confirmed 调 wait_for_success 或 wait_for_all_submitted。逻辑正确。
-- **ResultCollector**：submit 用无锁 ArrayQueue + 原子标志；wait_for_success 先看 success_flag/landed_failed_flag 再 drain results。先成功即返回，未 drain 到的后续结果会随 collector 丢弃，符合「任一成功即返回」语义。
-- **ensure_swqos_pool**：SWQOS_WORKERS_STARTED 用 swap 保证只初始化一次；队列由 execute_parallel 侧 get_or_init，再传给 ensure_swqos_pool，先起 worker 再 push，顺序正确。
-- **ensure_dedicated_pool**：在 Mutex 内判空、创建 queue/notify、spawn 线程、存 JoinHandles，返回 (queue, notify)。首次调用持锁完成初始化，后续调用每次持锁取 (queue, notify) 再返回。
-- **tip_cache**：用 `Arc::as_ptr(&swqos_client)` 做 key，按 client 身份去重，正确。
-
-## 2. 锁竞争与超低延迟
-
-- **DEDICATED_POOL 的 Mutex**：专属线程池开启时，**每次** execute_parallel 都会调 ensure_dedicated_pool，从而 **每次** 对 DEDICATED_POOL 加锁一次，仅为了读已有的 (queue, notify)。高并发下会成为争用点。
-- **优化**：初始化完成后，queue/notify 存到 OnceCell，热路径只做 OnceCell::get + Arc::clone，不再碰 Mutex。
-- **其余**：ArrayQueue（无锁 MPMC）、ResultCollector（ArrayQueue + 原子变量）、Notify 均无额外锁，合适。
-
-## 3. 已实现的优化
-
-- **专属池热路径无锁**：`DEDICATED_QUEUE` / `DEDICATED_NOTIFY` 改为 `OnceCell` 存储；`DEDICATED_INIT` 仅存 `JoinHandle` 并在初始化时持锁。热路径先读 OnceCell，命中则直接 `Arc::clone` 返回，不再加锁；未命中时再持锁做一次性初始化并 set OnceCell。
-
-## 4. 其他说明
-
-- **wait_for_success 与 drain**：先读 `success_flag` 再 `while let Some(...) = results.pop()` 时，若某 worker 刚 store(success) 尚未 push(result)，可能本轮 drain 为空，则 `!signatures.is_empty()` 不成立，不会 return，下一轮轮询会再 drain，逻辑正确。
-- **SWQOS_QUEUE / SWQOS_NOTIFY**：tokio 池侧已用 OnceCell，无每次加锁。

docs/TRADING_PARAMETERS.md

@@ -30,7 +30,7 @@ The `TradeBuyParams` struct contains all parameters required for executing buy o
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
 | `address_lookup_table_account` | `Option<AddressLookupTableAccount>` | ❌ | Address lookup table for transaction optimization |
-| `wait_transaction_confirmed` | `bool` | ✅ | Whether to wait for transaction confirmation |
+| `wait_tx_confirmed` | `bool` | ✅ | Whether to wait for transaction confirmation |
 | `create_input_token_ata` | `bool` | ✅ | Whether to create input token Associated Token Account |
 | `close_input_token_ata` | `bool` | ✅ | Whether to close input token ATA after transaction |
 | `create_mint_ata` | `bool` | ✅ | Whether to create token mint ATA |
@@ -62,7 +62,7 @@ The `TradeSellParams` struct contains all parameters required for executing sell
 | Parameter | Type | Required | Description |
 |-----------|------|----------|-------------|
 | `address_lookup_table_account` | `Option<Pubkey>` | ❌ | Address lookup table for transaction optimization |
-| `wait_transaction_confirmed` | `bool` | ✅ | Whether to wait for transaction confirmation |
+| `wait_tx_confirmed` | `bool` | ✅ | Whether to wait for transaction confirmation |
 | `create_output_token_ata` | `bool` | ✅ | Whether to create output token Associated Token Account |
 | `close_output_token_ata` | `bool` | ✅ | Whether to close output token ATA after transaction |
 | `durable_nonce` | `Option<DurableNonceInfo>` | ❌ | Durable nonce information containing nonce account and current nonce value |
@@ -88,7 +88,7 @@ These parameters are essential for defining the basic trading operation:
 These parameters control how the transaction is processed:
 
 - **slippage_basis_points**: Controls acceptable price slippage
-- **wait_transaction_confirmed**: Controls whether to wait for confirmation
+- **wait_tx_confirmed**: Controls whether to wait for confirmation
 
 ### 🔧 Account Management Parameters
 

docs/TRADING_PARAMETERS_CN.md

@@ -30,7 +30,7 @@
 | 参数 | 类型 | 必需 | 描述 |
 |------|------|------|------|
 | `address_lookup_table_account` | `Option<Pubkey>` | ❌ | 用于交易优化的地址查找表 |
-| `wait_transaction_confirmed` | `bool` | ✅ | 是否等待交易确认 |
+| `wait_tx_confirmed` | `bool` | ✅ | 是否等待交易确认 |
 | `create_input_token_ata` | `bool` | ✅ | 是否创建输入代币关联代币账户 |
 | `close_input_token_ata` | `bool` | ✅ | 交易后是否关闭输入代币 ATA |
 | `create_mint_ata` | `bool` | ✅ | 是否创建代币 mint ATA |
@@ -62,7 +62,7 @@
 | 参数 | 类型 | 必需 | 描述 |
 |------|------|------|------|
 | `address_lookup_table_account` | `Option<AddressLookupTableAccount>` | ❌ | 用于交易优化的地址查找表 |
-| `wait_transaction_confirmed` | `bool` | ✅ | 是否等待交易确认 |
+| `wait_tx_confirmed` | `bool` | ✅ | 是否等待交易确认 |
 | `create_output_token_ata` | `bool` | ✅ | 是否创建输出代币关联代币账户 |
 | `close_output_token_ata` | `bool` | ✅ | 交易后是否关闭输出代币 ATA |
 | `durable_nonce` | `Option<DurableNonceInfo>` | ❌ | 持久 nonce 信息，包含 nonce 账户和当前 nonce 值 |
@@ -88,7 +88,7 @@
 这些参数控制交易的处理方式：
 
 - **slippage_basis_points**: 控制可接受的价格滑点
-- **wait_transaction_confirmed**: 控制是否等待确认
+- **wait_tx_confirmed**: 控制是否等待确认
 
 ### 🔧 账户管理参数
 

src/common/sdk_log.rs

@@ -3,10 +3,59 @@
 //! Controlled by `TradeConfig::log_enabled`, set in `TradingClient::new`.
 //! All SDK logs (timing, SWQOS submit/confirm, WSOL, blacklist, etc.) should check this before output.
 
+use std::fmt;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::time::Duration;
+
+/// Format duration for log: "97.9396 ms" or "13.936 µs", 4 decimal places, space before unit.
+fn format_elapsed(d: Duration) -> String {
+    let secs = d.as_secs_f64();
+    if secs < 0.001 {
+        format!("{:.4} µs", secs * 1_000_000.0)
+    } else {
+        format!("{:.4} ms", secs * 1000.0)
+    }
+}
+
+/// Extract a short error message for SWQOS submission failed log.
+/// Tries JSON "message"/"data" and quoted string; on any parse failure returns original (no panic).
+fn extract_swqos_error_message(s: &str) -> String {
+    let s = s.trim();
+    if s.is_empty() {
+        return String::new();
+    }
+    // Plain double-quoted string (no inner JSON): unquote
+    if s.starts_with('"') && s.ends_with('"') && s.len() >= 2 {
+        let inner = &s[1..s.len() - 1];
+        if !inner.contains('{') {
+            return inner.replace("\\\"", "\"");
+        }
+    }
+    // Try parse as JSON only when input looks like JSON (avoid parsing long non-JSON strings)
+    if s.starts_with('{') {
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(s) {
+            let obj = v
+                .get("error")
+                .and_then(|e| e.as_object())
+                .or_else(|| v.as_object());
+            if let Some(o) = obj {
+                if let Some(m) = o.get("message").and_then(|x| x.as_str()) {
+                    return m.to_string();
+                }
+                if let Some(d) = o.get("data").and_then(|x| x.as_str()) {
+                    return d.to_string();
+                }
+            }
+        }
+    }
+    s.to_string()
+}
 
 static SDK_LOG_ENABLED: AtomicBool = AtomicBool::new(true);
 
+/// Width of [provider] label so SWQOS submit/confirm lines align (longest: Speedlanding).
+pub const SWQOS_LABEL_WIDTH: usize = 12;
+
 /// Whether SDK logging is enabled (set from TradeConfig.log_enabled in TradingClient::new).
 #[inline(always)]
 pub fn sdk_log_enabled() -> bool {
@@ -17,3 +66,103 @@ pub fn sdk_log_enabled() -> bool {
 pub fn set_sdk_log_enabled(enabled: bool) {
     SDK_LOG_ENABLED.store(enabled, Ordering::Relaxed);
 }
+
+/// Aligned log: ` [Soyas        ] Buy submitted: 13.936 µs`. Call only when sdk_log_enabled().
+#[inline]
+pub fn log_swqos_submitted(
+    provider: &str,
+    trade_type: impl fmt::Display,
+    elapsed: Duration,
+) {
+    println!(
+        " [{:width$}] {} submitted: {}",
+        provider,
+        trade_type,
+        format_elapsed(elapsed),
+        width = SWQOS_LABEL_WIDTH
+    );
+}
+
+/// Prints one SDK timing block (build_instructions, before_submit, per-channel submit_done).
+/// When confirm_us is Some, prints confirmed + total; when None, prints "confirmed: -, total: submit_ms".
+/// Call only when sdk_log_enabled().
+pub fn print_sdk_timing_block(
+    dir: &str,
+    start_us: Option<i64>,
+    build_end_us: Option<i64>,
+    before_submit_us: Option<i64>,
+    submit_timings: &[(crate::swqos::SwqosType, i64)],
+    confirm_us: Option<i64>,
+) {
+    println!();
+    let start_us = match start_us {
+        Some(u) => u,
+        None => return,
+    };
+    if let Some(end_us) = build_end_us {
+        println!(
+            " [SDK][{:width$}] {} build_instructions: {:.4} ms",
+            "-",
+            dir,
+            (end_us - start_us) as f64 / 1000.0,
+            width = SWQOS_LABEL_WIDTH
+        );
+    }
+    if let Some(end_us) = before_submit_us {
+        println!(
+            " [SDK][{:width$}] {} before_submit: {:.4} ms",
+            "-",
+            dir,
+            (end_us - start_us) as f64 / 1000.0,
+            width = SWQOS_LABEL_WIDTH
+        );
+    }
+    if let Some(confirm_done_us) = confirm_us {
+        let total_ms = (confirm_done_us - start_us) as f64 / 1000.0;
+        for (swqos_type, submit_done_us) in submit_timings {
+            let submit_ms = (*submit_done_us - start_us).max(0) as f64 / 1000.0;
+            let confirmed_ms = (confirm_done_us - *submit_done_us).max(0) as f64 / 1000.0;
+            println!(
+                " [SDK][{:width$}] {} submit_done: {:.4} ms, confirmed: {:.4} ms, total: {:.4} ms",
+                swqos_type.as_str(),
+                dir,
+                submit_ms,
+                confirmed_ms,
+                total_ms,
+                width = SWQOS_LABEL_WIDTH
+            );
+        }
+    } else {
+        for (swqos_type, submit_done_us) in submit_timings {
+            let submit_ms = (*submit_done_us - start_us).max(0) as f64 / 1000.0;
+            println!(
+                " [SDK][{:width$}] {} submit_done: {:.4} ms, confirmed: -, total: {:.4} ms",
+                swqos_type.as_str(),
+                dir,
+                submit_ms,
+                submit_ms,
+                width = SWQOS_LABEL_WIDTH
+            );
+        }
+    }
+}
+
+/// Aligned log: ` [Stellium     ] Buy submission failed after 97.9396 ms: ...`. Call only when sdk_log_enabled().
+/// Error is normalized: JSON "message"/"data" or quoted string is shown; raw JSON is not.
+#[inline]
+pub fn log_swqos_submission_failed(
+    provider: &str,
+    trade_type: impl fmt::Display,
+    elapsed: Duration,
+    err: impl fmt::Display,
+) {
+    let msg = extract_swqos_error_message(&format!("{}", err));
+    eprintln!(
+        " [{:width$}] {} submission failed after {}, error: {}",
+        provider,
+        trade_type,
+        format_elapsed(elapsed),
+        msg,
+        width = SWQOS_LABEL_WIDTH
+    );
+}

src/common/types.rs

@@ -9,6 +9,8 @@ pub struct InfrastructureConfig {
     pub rpc_url: String,
     pub swqos_configs: Vec<SwqosConfig>,
     pub commitment: CommitmentConfig,
+    /// When true, SWQOS sender threads use the *last* N cores instead of the first N. Reduces contention with main thread / default tokio workers that often use low-numbered cores. Default false.
+    pub swqos_cores_from_end: bool,
 }
 
 impl InfrastructureConfig {
@@ -17,7 +19,12 @@ impl InfrastructureConfig {
         swqos_configs: Vec<SwqosConfig>,
         commitment: CommitmentConfig,
     ) -> Self {
-        Self { rpc_url, swqos_configs, commitment }
+        Self {
+            rpc_url,
+            swqos_configs,
+            commitment,
+            swqos_cores_from_end: false,
+        }
     }
 
     /// Create from TradeConfig (extract infrastructure-only settings)
@@ -26,6 +33,7 @@ impl InfrastructureConfig {
             rpc_url: config.rpc_url.clone(),
             swqos_configs: config.swqos_configs.clone(),
             commitment: config.commitment.clone(),
+            swqos_cores_from_end: config.swqos_cores_from_end,
         }
     }
 
@@ -43,8 +51,8 @@ impl Hash for InfrastructureConfig {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.rpc_url.hash(state);
         self.swqos_configs.hash(state);
-        // Hash commitment level as string since CommitmentConfig doesn't impl Hash
         format!("{:?}", self.commitment).hash(state);
+        self.swqos_cores_from_end.hash(state);
     }
 }
 
@@ -53,6 +61,7 @@ impl PartialEq for InfrastructureConfig {
         self.rpc_url == other.rpc_url
             && self.swqos_configs == other.swqos_configs
             && self.commitment == other.commitment
+            && self.swqos_cores_from_end == other.swqos_cores_from_end
     }
 }
 
@@ -68,16 +77,12 @@ pub struct TradeConfig {
     pub create_wsol_ata_on_startup: bool,
     /// Whether to use seed optimization for all ATA operations (default: true)
     pub use_seed_optimize: bool,
-    /// Whether to pin parallel submit tasks to CPU cores (can reduce latency; set false in containers). Default true.
-    pub use_core_affinity: bool,
-    /// Use dedicated OS threads for sender pool (opt-in). When true, N threads run only send work; default N=18. Reduces scheduling contention when sending many txs. Default false.
-    pub use_dedicated_sender_threads: bool,
-    /// When use_dedicated_sender_threads is true, core indices to pin each sender thread to. If None or empty, N=SWQOS_DEDICATED_DEFAULT_THREADS with no affinity. If Some(ids), N=ids.len() and threads are pinned to these cores. Arc avoids cloning the Vec when building params.
-    pub sender_thread_cores: Option<std::sync::Arc<Vec<usize>>>,
     /// Whether to output all SDK logs (timing, SWQOS submit/confirm, WSOL, blacklist, etc.). Default true.
     pub log_enabled: bool,
     /// Whether to check minimum tip per SWQOS provider (filter out configs below min). Default false to save latency.
     pub check_min_tip: bool,
+    /// When true, SWQOS uses the *last* N cores (instead of the first N). Use when main thread / tokio use low-numbered cores to reduce CPU contention. Default false.
+    pub swqos_cores_from_end: bool,
 }
 
 impl TradeConfig {
@@ -95,12 +100,10 @@ impl TradeConfig {
             swqos_configs,
             commitment,
             create_wsol_ata_on_startup: true, // default: check and create on startup
-            use_seed_optimize: true,          // default: use seed optimization
-            use_core_affinity: true,          // default: pin parallel submit tasks to cores
-            use_dedicated_sender_threads: false, // default: use tokio worker pool
-            sender_thread_cores: None,        // when dedicated threads enabled, which cores to pin (None => default count, no affinity)
-            log_enabled: true,                // default: enable all SDK logs
-            check_min_tip: false,             // default: skip min tip check to reduce latency
+            use_seed_optimize: true, // default: use seed optimization
+            log_enabled: true,      // default: enable all SDK logs
+            check_min_tip: false,   // default: skip min tip check to reduce latency
+            swqos_cores_from_end: false,
         }
     }
 
@@ -120,6 +123,12 @@ impl TradeConfig {
         self.check_min_tip = check_min_tip;
         self
     }
+
+    /// Use the *last* N cores for SWQOS (instead of the first N). Call this when the main thread or tokio workers use low-numbered cores to avoid binding SWQOS to busy cores. Default false.
+    pub fn with_swqos_cores_from_end(mut self, from_end: bool) -> Self {
+        self.swqos_cores_from_end = from_end;
+        self
+    }
 }
 
 pub type SolanaRpcClient = solana_client::nonblocking::rpc_client::RpcClient;

src/lib.rs

@@ -90,6 +90,10 @@ pub struct TradingInfrastructure {
     pub swqos_clients: Arc<Vec<Arc<SwqosClient>>>,
     /// Configuration used to create this infrastructure
     pub config: InfrastructureConfig,
+    /// Precomputed at init: min(swqos_clients.len(), 2/3 * num_cores). Not computed on trade hot path.
+    pub max_sender_concurrency: usize,
+    /// Precomputed at init: first max_sender_concurrency CoreIds for job affinity. Empty if no cores. Not computed on trade hot path.
+    pub effective_core_ids: Arc<Vec<core_affinity::CoreId>>,
 }
 
 impl TradingInfrastructure {
@@ -175,14 +179,52 @@ impl TradingInfrastructure {
             }
         }
 
+        let swqos_count = swqos_clients.len();
+        let (max_sender_concurrency, effective_core_ids) = {
+            let num_cores = core_affinity::get_core_ids().map(|c| c.len()).unwrap_or(0);
+            let max_by_cores = (num_cores * 2 / 3).max(1);
+            let cap = swqos_count.min(max_by_cores).max(1);
+            let ids = core_affinity::get_core_ids()
+                .map(|all| {
+                    let v: Vec<_> = all.into_iter().collect();
+                    let len = v.len();
+                    if config.swqos_cores_from_end && len >= cap {
+                        v.into_iter().skip(len - cap).collect()
+                    } else {
+                        v.into_iter().take(cap).collect()
+                    }
+                })
+                .unwrap_or_default();
+            (cap, Arc::new(ids))
+        };
+
         Self {
             rpc,
             swqos_clients: Arc::new(swqos_clients),
             config,
+            max_sender_concurrency,
+            effective_core_ids,
         }
     }
 }
 
+/// When using `TradeConfig::with_swqos_cores_from_end(true)`, returns the same "last N" core indices
+/// that the infrastructure uses. Pass the result to `TradingClient::with_dedicated_sender_threads`
+/// for 方式 C (组合使用): SWQOS on last N cores and dedicated sender threads pinned to those cores.
+///
+/// Returns `None` if core count cannot be determined. `swqos_count` is typically `swqos_configs.len()`.
+pub fn recommended_sender_thread_core_indices(swqos_count: usize) -> Option<Vec<usize>> {
+    let all = core_affinity::get_core_ids()?;
+    let num_cores = all.len();
+    if num_cores == 0 {
+        return None;
+    }
+    let max_by_cores = (num_cores * 2 / 3).max(1);
+    let cap = swqos_count.min(max_by_cores).max(1).min(num_cores);
+    let start = num_cores.saturating_sub(cap);
+    Some((start..num_cores).collect())
+}
+
 /// Main trading client for Solana DeFi protocols
 ///
 /// `SolTradingSDK` provides a unified interface for trading across multiple Solana DEXs
@@ -199,12 +241,14 @@ pub struct TradingClient {
     /// Whether to use seed optimization for all ATA operations (default: true)
     /// Applies to all token account creations across buy and sell operations
     pub use_seed_optimize: bool,
-    /// Whether to pin parallel submit tasks to CPU cores (from TradeConfig.use_core_affinity). Default true.
-    pub use_core_affinity: bool,
-    /// Use dedicated sender threads (from TradeConfig.use_dedicated_sender_threads). Default false.
+    /// Internal: use dedicated sender threads (default false). Set via with_dedicated_sender_threads() for advanced use.
     pub use_dedicated_sender_threads: bool,
-    /// Core indices for dedicated sender threads (from TradeConfig.sender_thread_cores). Arc avoids cloning the Vec when building SwapParams.
+    /// Internal: core indices for dedicated sender threads. Trimmed to ≤ max_sender_concurrency at set.
     pub sender_thread_cores: Option<Arc<Vec<usize>>>,
+    /// Internal: precomputed at infra init (min(swqos_count, 2/3*cores)). Not user-configurable.
+    pub max_sender_concurrency: usize,
+    /// Internal: precomputed at infra init for job affinity. Not user-configurable.
+    pub effective_core_ids: Arc<Vec<core_affinity::CoreId>>,
     /// Whether to output all SDK logs (from TradeConfig.log_enabled).
     pub log_enabled: bool,
     /// Whether to check minimum tip per SWQOS (from TradeConfig.check_min_tip). Default false for lower latency.
@@ -223,9 +267,10 @@ impl Clone for TradingClient {
             infrastructure: self.infrastructure.clone(),
             middleware_manager: self.middleware_manager.clone(),
             use_seed_optimize: self.use_seed_optimize,
-            use_core_affinity: self.use_core_affinity,
             use_dedicated_sender_threads: self.use_dedicated_sender_threads,
             sender_thread_cores: self.sender_thread_cores.clone(),
+            max_sender_concurrency: self.max_sender_concurrency,
+            effective_core_ids: self.effective_core_ids.clone(),
             log_enabled: self.log_enabled,
             check_min_tip: self.check_min_tip,
         }
@@ -257,7 +302,7 @@ pub struct TradeBuyParams {
     /// Optional address lookup table for transaction size optimization
     pub address_lookup_table_account: Option<AddressLookupTableAccount>,
     /// Whether to wait for transaction confirmation before returning
-    pub wait_transaction_confirmed: bool,
+    pub wait_tx_confirmed: bool,
     /// Whether to create input token associated token account
     pub create_input_token_ata: bool,
     /// Whether to close input token associated token account after trade
@@ -308,7 +353,7 @@ pub struct TradeSellParams {
     /// Optional address lookup table for transaction size optimization
     pub address_lookup_table_account: Option<AddressLookupTableAccount>,
     /// Whether to wait for transaction confirmation before returning
-    pub wait_transaction_confirmed: bool,
+    pub wait_tx_confirmed: bool,
     /// Whether to create output token associated token account
     pub create_output_token_ata: bool,
     /// Whether to close output token associated token account after trade
@@ -348,15 +393,18 @@ impl TradingClient {
     ) -> Self {
         // Initialize wallet-specific caches (fast, synchronous)
         crate::common::fast_fn::fast_init(&payer.pubkey());
+        let max_sender_concurrency = infrastructure.max_sender_concurrency;
+        let effective_core_ids = infrastructure.effective_core_ids.clone();
 
         Self {
             payer,
             infrastructure,
             middleware_manager: None,
             use_seed_optimize,
-            use_core_affinity: true,
             use_dedicated_sender_threads: false,
             sender_thread_cores: None,
+            max_sender_concurrency,
+            effective_core_ids,
             log_enabled: true,
             check_min_tip: false,
         }
@@ -391,14 +439,18 @@ impl TradingClient {
             }
         }
 
+        let max_sender_concurrency = infrastructure.max_sender_concurrency;
+        let effective_core_ids = infrastructure.effective_core_ids.clone();
+
         Self {
             payer,
             infrastructure,
             middleware_manager: None,
             use_seed_optimize,
-            use_core_affinity: true,
             use_dedicated_sender_threads: false,
             sender_thread_cores: None,
+            max_sender_concurrency,
+            effective_core_ids,
             log_enabled: true,
             check_min_tip: false,
         }
@@ -568,14 +620,16 @@ impl TradingClient {
             }
         }
 
+        // 并发/核心相关由 infrastructure 预计算，用户无需配置
         let instance = Self {
             payer,
-            infrastructure,
+            infrastructure: infrastructure.clone(),
             middleware_manager: None,
             use_seed_optimize: trade_config.use_seed_optimize,
-            use_core_affinity: trade_config.use_core_affinity,
-            use_dedicated_sender_threads: trade_config.use_dedicated_sender_threads,
-            sender_thread_cores: trade_config.sender_thread_cores.clone(),
+            use_dedicated_sender_threads: false,
+            sender_thread_cores: None,
+            max_sender_concurrency: infrastructure.max_sender_concurrency,
+            effective_core_ids: infrastructure.effective_core_ids.clone(),
             log_enabled: trade_config.log_enabled,
             check_min_tip: trade_config.check_min_tip,
         };
@@ -601,6 +655,34 @@ impl TradingClient {
         self
     }
 
+    /// **Advanced.** Use dedicated OS threads for sender pool (and optionally pin to cores).  
+    /// By default the SDK uses a shared tokio pool; this can reduce scheduling contention when sending many txs.  
+    /// Concurrency and core count are capped internally (≤ swqos count, ≤ 2/3 of CPU cores).  
+    /// - `None`: keep default (shared tokio pool).  
+    /// - `Some(vec![])`: dedicated threads with default count, no core pinning.  
+    /// - `Some(indices)`: dedicated threads pinned to those core indices (trimmed to cap).  
+    ///  
+    /// **Latency note:** If a core is busy with other work (node, bot), SWQOS submit on that core can be delayed.  
+    /// For lowest latency, pass core indices that are *reserved* for SWQOS (do not run other CPU-heavy work on those cores).
+    pub fn with_dedicated_sender_threads(mut self, core_indices: Option<Vec<usize>>) -> Self {
+        match core_indices {
+            None => {
+                self.use_dedicated_sender_threads = false;
+                self.sender_thread_cores = None;
+            }
+            Some(v) if v.is_empty() => {
+                self.use_dedicated_sender_threads = true;
+                self.sender_thread_cores = None;
+            }
+            Some(v) => {
+                self.use_dedicated_sender_threads = true;
+                let cap = v.len().min(self.max_sender_concurrency);
+                self.sender_thread_cores = Some(Arc::new(if cap < v.len() { v[..cap].to_vec() } else { v }));
+            }
+        }
+        self
+    }
+
     /// Gets the RPC client instance for direct Solana blockchain interactions
     ///
     /// This provides access to the underlying Solana RPC client that can be used
@@ -706,7 +788,7 @@ impl TradingClient {
             slippage_basis_points: params.slippage_basis_points,
             address_lookup_table_account: params.address_lookup_table_account,
             recent_blockhash: params.recent_blockhash,
-            wait_transaction_confirmed: params.wait_transaction_confirmed,
+            wait_tx_confirmed: params.wait_tx_confirmed,
             protocol_params,
             open_seed_optimize: self.use_seed_optimize, // 使用全局seed优化配置
             swqos_clients: self.infrastructure.swqos_clients.clone(),
@@ -721,9 +803,10 @@ impl TradingClient {
             gas_fee_strategy: params.gas_fee_strategy,
             simulate: params.simulate,
             log_enabled: self.log_enabled,
-            use_core_affinity: self.use_core_affinity,
             use_dedicated_sender_threads: self.use_dedicated_sender_threads,
             sender_thread_cores: self.sender_thread_cores.clone(),
+            max_sender_concurrency: self.max_sender_concurrency,
+            effective_core_ids: self.effective_core_ids.clone(),
             check_min_tip: self.check_min_tip,
             grpc_recv_us: params.grpc_recv_us,
             use_exact_sol_amount: params.use_exact_sol_amount,
@@ -812,7 +895,7 @@ impl TradingClient {
             slippage_basis_points: params.slippage_basis_points,
             address_lookup_table_account: params.address_lookup_table_account,
             recent_blockhash: params.recent_blockhash,
-            wait_transaction_confirmed: params.wait_transaction_confirmed,
+            wait_tx_confirmed: params.wait_tx_confirmed,
             protocol_params,
             with_tip: params.with_tip,
             open_seed_optimize: self.use_seed_optimize, // 使用全局seed优化配置
@@ -827,9 +910,10 @@ impl TradingClient {
             gas_fee_strategy: params.gas_fee_strategy,
             simulate: params.simulate,
             log_enabled: self.log_enabled,
-            use_core_affinity: self.use_core_affinity,
             use_dedicated_sender_threads: self.use_dedicated_sender_threads,
             sender_thread_cores: self.sender_thread_cores.clone(),
+            max_sender_concurrency: self.max_sender_concurrency,
+            effective_core_ids: self.effective_core_ids.clone(),
             check_min_tip: self.check_min_tip,
             grpc_recv_us: params.grpc_recv_us,
             use_exact_sol_amount: None,

src/swqos/astralane.rs

@@ -2,7 +2,7 @@ use crate::swqos::common::{default_http_client_builder, poll_transaction_confirm
 use rand::seq::IndexedRandom;
 use reqwest::Client;
 use std::{sync::Arc, time::Instant};
-use tracing::{error, info, warn};
+use tracing::warn;
 
 use crate::swqos::SwqosClientTrait;
 use crate::swqos::{SwqosType, TradeType};
@@ -193,15 +193,26 @@ impl AstralaneClient {
                 let status = response.status();
                 let _ = response.bytes().await;
                 if status.is_success() {
-                    info!(target: "sol_trade_sdk", "[astralane] {} submitted: {:?}", trade_type, start_time.elapsed());
+                    if crate::common::sdk_log::sdk_log_enabled() {
+                        crate::common::sdk_log::log_swqos_submitted("Astralane", trade_type, start_time.elapsed());
+                    }
                 } else {
-                    error!(target: "sol_trade_sdk", "[astralane] {} submission failed: status {}", trade_type, status);
+                    if crate::common::sdk_log::sdk_log_enabled() {
+                        crate::common::sdk_log::log_swqos_submission_failed("Astralane", trade_type, start_time.elapsed(), format!("status {}", status));
+                    }
                     return Err(anyhow::anyhow!("Astralane sendTransaction failed: {}", status));
                 }
             }
             AstralaneBackend::Quic(quic) => {
-                quic.send_transaction(&body_bytes).await?;
-                info!(target: "sol_trade_sdk", "[astralane-quic] {} submitted: {:?}", trade_type, start_time.elapsed());
+                if let Err(e) = quic.send_transaction(&body_bytes).await {
+                    if crate::common::sdk_log::sdk_log_enabled() {
+                        crate::common::sdk_log::log_swqos_submission_failed("Astralane", trade_type, start_time.elapsed(), &e);
+                    }
+                    return Err(e);
+                }
+                if crate::common::sdk_log::sdk_log_enabled() {
+                    crate::common::sdk_log::log_swqos_submitted("Astralane", trade_type, start_time.elapsed());
+                }
             }
         }
 
@@ -209,14 +220,16 @@ impl AstralaneClient {
         match poll_transaction_confirmation(&self.rpc_client, *signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
-                info!(target: "sol_trade_sdk", "signature: {:?}", signature);
-                error!(target: "sol_trade_sdk", "[astralane] {} confirmation failed: {:?}", trade_type, start_time.elapsed());
+                if crate::common::sdk_log::sdk_log_enabled() {
+                    println!(" signature: {:?}", signature);
+                    println!(" [{:width$}] {} confirmation failed: {:?}", "Astralane", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
+                }
                 return Err(e);
             }
         }
-        if wait_confirmation {
-            info!(target: "sol_trade_sdk", "signature: {:?}", signature);
-            info!(target: "sol_trade_sdk", "[astralane] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation && crate::common::sdk_log::sdk_log_enabled() {
+            println!(" signature: {:?}", signature);
+            println!(" [{:width$}] {} confirmed: {:?}", "Astralane", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
         Ok(())
     }

src/swqos/blockrazor.rs

@@ -172,15 +172,12 @@ impl BlockRazorClient {
         if status.is_success() {
             let _ = response.bytes().await;
             if crate::common::sdk_log::sdk_log_enabled() {
-                println!(" [blockrazor] {} submitted: {:?}", trade_type, start_time.elapsed());
+                crate::common::sdk_log::log_swqos_submitted("blockrazor", trade_type, start_time.elapsed());
             }
         } else {
             let body = response.text().await.unwrap_or_default();
             if crate::common::sdk_log::sdk_log_enabled() {
-                eprintln!(
-                    " [blockrazor] {} submission failed: status {} body: {}",
-                    trade_type, status, body
-                );
+                crate::common::sdk_log::log_swqos_submission_failed("blockrazor", trade_type, start_time.elapsed(), format!("status {} body: {}", status, body));
             }
             return Err(anyhow::anyhow!(
                 "BlockRazor sendTransaction failed: status {} body: {}",
@@ -196,9 +193,11 @@ impl BlockRazorClient {
                 if crate::common::sdk_log::sdk_log_enabled() {
                     println!(" signature: {:?}", signature);
                     println!(
-                        " [blockrazor] {} confirmation failed: {:?}",
+                        " [{:width$}] {} confirmation failed: {:?}",
+                        "blockrazor",
                         trade_type,
-                        start_time.elapsed()
+                        start_time.elapsed(),
+                        width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
                     );
                 }
                 return Err(e);
@@ -206,7 +205,7 @@ impl BlockRazorClient {
         }
         if wait_confirmation && crate::common::sdk_log::sdk_log_enabled() {
             println!(" signature: {:?}", signature);
-            println!(" [blockrazor] {} confirmed: {:?}", trade_type, start_time.elapsed());
+            println!(" [{:width$}] {} confirmed: {:?}", "blockrazor", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
 
         Ok(())

src/swqos/bloxroute.rs

@@ -100,13 +100,13 @@ impl BloxrouteClient {
         if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
             if crate::common::sdk_log::sdk_log_enabled() {
                 if response_json.get("result").is_some() {
-                    println!(" [bloxroute] {} submitted: {:?}", trade_type, start_time.elapsed());
+                    crate::common::sdk_log::log_swqos_submitted("bloxroute", trade_type, start_time.elapsed());
                 } else if let Some(_error) = response_json.get("error") {
-                    eprintln!(" [bloxroute] {} submission failed: {:?}", trade_type, _error);
+                    eprintln!(" [bloxroute] {} submission failed after {:?}: {:?}", trade_type, start_time.elapsed(), _error);
                 }
             }
         } else if crate::common::sdk_log::sdk_log_enabled() {
-            eprintln!(" [bloxroute] {} submission failed: {:?}", trade_type, response_text);
+            crate::common::sdk_log::log_swqos_submission_failed("bloxroute", trade_type, start_time.elapsed(), response_text);
         }
 
         let start_time: Instant = Instant::now();
@@ -116,9 +116,11 @@ impl BloxrouteClient {
                 if crate::common::sdk_log::sdk_log_enabled() {
                     println!(" signature: {:?}", signature);
                     println!(
-                        " [bloxroute] {} confirmation failed: {:?}",
+                        " [{:width$}] {} confirmation failed: {:?}",
+                        "bloxroute",
                         trade_type,
-                        start_time.elapsed()
+                        start_time.elapsed(),
+                        width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
                     );
                 }
                 return Err(e);
@@ -126,7 +128,7 @@ impl BloxrouteClient {
         }
         if wait_confirmation && crate::common::sdk_log::sdk_log_enabled() {
             println!(" signature: {:?}", signature);
-            println!(" [bloxroute] {} confirmed: {:?}", trade_type, start_time.elapsed());
+            println!(" [{:width$}] {} confirmed: {:?}", "bloxroute", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
 
         Ok(())
@@ -168,7 +170,7 @@ impl BloxrouteClient {
                 if response_json.get("result").is_some() {
                     println!(" bloxroute {} submitted: {:?}", trade_type, start_time.elapsed());
                 } else if let Some(_error) = response_json.get("error") {
-                    eprintln!(" bloxroute {} submission failed: {:?}", trade_type, _error);
+                    eprintln!(" bloxroute {} submission failed after {:?}: {:?}", trade_type, start_time.elapsed(), _error);
                 }
             }
         }

src/swqos/flashblock.rs

@@ -97,12 +97,12 @@ impl FlashBlockClient {
         // Parse response
         if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
             if response_json.get("success").is_some() || response_json.get("result").is_some() {
-                println!(" [FlashBlock] {} submitted: {:?}", trade_type, start_time.elapsed());
+                crate::common::sdk_log::log_swqos_submitted("FlashBlock", trade_type, start_time.elapsed());
             } else if let Some(_error) = response_json.get("error") {
-                eprintln!(" [FlashBlock] {} submission failed: {:?}", trade_type, _error);
+                eprintln!(" [FlashBlock] {} submission failed after {:?}: {:?}", trade_type, start_time.elapsed(), _error);
             }
         } else {
-            eprintln!(" [FlashBlock] {} submission failed: {:?}", trade_type, response_text);
+            crate::common::sdk_log::log_swqos_submission_failed("FlashBlock", trade_type, start_time.elapsed(), response_text);
         }
 
         let start_time: Instant = Instant::now();
@@ -111,16 +111,18 @@ impl FlashBlockClient {
             Err(e) => {
                 println!(" signature: {:?}", signature);
                 println!(
-                    " [FlashBlock] {} confirmation failed: {:?}",
+                    " [{:width$}] {} confirmation failed: {:?}",
+                    "FlashBlock",
                     trade_type,
-                    start_time.elapsed()
+                    start_time.elapsed(),
+                    width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
                 );
                 return Err(e);
             }
         }
         if wait_confirmation {
             println!(" signature: {:?}", signature);
-            println!(" [FlashBlock] {} confirmed: {:?}", trade_type, start_time.elapsed());
+            println!(" [{:width$}] {} confirmed: {:?}", "FlashBlock", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
 
         Ok(())

src/swqos/helius.rs

@@ -106,8 +106,8 @@ impl HeliusClient {
         if !status.is_success() {
             if crate::common::sdk_log::sdk_log_enabled() {
                 eprintln!(
-                    " [helius] {} submission failed status={} body={}",
-                    trade_type, status, response_text
+                    " [helius] {} submission failed after {:?} status={} body={}",
+                    trade_type, start_time.elapsed(), status, response_text
                 );
             }
             return Err(anyhow::anyhow!(
@@ -124,15 +124,15 @@ impl HeliusClient {
                     .and_then(|v| v.as_str())
                     .unwrap_or("unknown");
                 if crate::common::sdk_log::sdk_log_enabled() {
-                    eprintln!(" [helius] {} submission error: {}", trade_type, err_msg);
+                    crate::common::sdk_log::log_swqos_submission_failed("helius", trade_type, start_time.elapsed(), err_msg);
                 }
                 return Err(anyhow::anyhow!("Helius Sender error: {}", err_msg));
             }
             if response_json.get("result").is_some() && crate::common::sdk_log::sdk_log_enabled() {
-                println!(" [helius] {} submitted: {:?}", trade_type, start_time.elapsed());
+                crate::common::sdk_log::log_swqos_submitted("helius", trade_type, start_time.elapsed());
             }
         } else if crate::common::sdk_log::sdk_log_enabled() {
-            eprintln!(" [helius] {} submission failed: {:?}", trade_type, response_text);
+            crate::common::sdk_log::log_swqos_submission_failed("helius", trade_type, start_time.elapsed(), response_text);
         }
 
         match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
@@ -140,9 +140,11 @@ impl HeliusClient {
             Err(e) => {
                 if crate::common::sdk_log::sdk_log_enabled() {
                     eprintln!(
-                        " [helius] {} confirmation failed: {:?}",
+                        " [{:width$}] {} confirmation failed: {:?}",
+                        "helius",
                         trade_type,
-                        start_time.elapsed()
+                        start_time.elapsed(),
+                        width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
                     );
                 }
                 return Err(e);
@@ -150,7 +152,7 @@ impl HeliusClient {
         }
         if wait_confirmation && crate::common::sdk_log::sdk_log_enabled() {
             println!(" signature: {:?}", signature);
-            println!(" [helius] {} confirmed: {:?}", trade_type, start_time.elapsed());
+            println!(" [{:width$}] {} confirmed: {:?}", "helius", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
         Ok(())
     }

src/swqos/jito.rs

@@ -105,12 +105,12 @@ impl JitoClient {
 
         if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
             if response_json.get("result").is_some() {
-                println!(" [jito] {} submitted: {:?}", trade_type, start_time.elapsed());
+                crate::common::sdk_log::log_swqos_submitted("jito", trade_type, start_time.elapsed());
             } else if let Some(_error) = response_json.get("error") {
-                eprintln!(" [jito] {} submission failed: {:?}", trade_type, _error);
+                eprintln!(" [jito] {} submission failed after {:?}: {:?}", trade_type, start_time.elapsed(), _error);
             }
         } else {
-            eprintln!(" [jito] {} submission failed: {:?}", trade_type, response_text);
+            crate::common::sdk_log::log_swqos_submission_failed("jito", trade_type, start_time.elapsed(), response_text);
         }
 
         let start_time: Instant = Instant::now();
@@ -118,13 +118,13 @@ impl JitoClient {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
-                println!(" [jito] {} confirmation failed: {:?}", trade_type, start_time.elapsed());
+                println!(" [{:width$}] {} confirmation failed: {:?}", "jito", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
                 return Err(e);
             }
         }
         if wait_confirmation {
             println!(" signature: {:?}", signature);
-            println!(" [jito] {} confirmed: {:?}", trade_type, start_time.elapsed());
+            println!(" [{:width$}] {} confirmed: {:?}", "jito", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
 
         Ok(())
@@ -171,7 +171,7 @@ impl JitoClient {
             if response_json.get("result").is_some() {
                 println!(" jito {} submitted: {:?}", trade_type, start_time.elapsed());
             } else if let Some(_error) = response_json.get("error") {
-                eprintln!(" jito {} submission failed: {:?}", trade_type, _error);
+                eprintln!(" jito {} submission failed after {:?}: {:?}", trade_type, start_time.elapsed(), _error);
             }
         }
 

src/swqos/lightspeed.rs

@@ -103,12 +103,12 @@ impl LightspeedClient {
 
         if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
             if response_json.get("result").is_some() {
-                println!(" [lightspeed] {} submitted: {:?}", trade_type, start_time.elapsed());
+                crate::common::sdk_log::log_swqos_submitted("lightspeed", trade_type, start_time.elapsed());
             } else if let Some(_error) = response_json.get("error") {
-                eprintln!(" [lightspeed] {} submission failed: {:?}", trade_type, _error);
+                crate::common::sdk_log::log_swqos_submission_failed("lightspeed", trade_type, start_time.elapsed(), _error);
             }
         } else {
-            eprintln!(" [lightspeed] {} submission failed: {:?}", trade_type, response_text);
+            crate::common::sdk_log::log_swqos_submission_failed("lightspeed", trade_type, start_time.elapsed(), response_text);
         }
 
         let start_time: Instant = Instant::now();
@@ -117,16 +117,18 @@ impl LightspeedClient {
             Err(e) => {
                 println!(" signature: {:?}", signature);
                 println!(
-                    " [lightspeed] {} confirmation failed: {:?}",
+                    " [{:width$}] {} confirmation failed: {:?}",
+                    "lightspeed",
                     trade_type,
-                    start_time.elapsed()
+                    start_time.elapsed(),
+                    width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
                 );
                 return Err(e);
             }
         }
         if wait_confirmation {
             println!(" signature: {:?}", signature);
-            println!(" [lightspeed] {} confirmed: {:?}", trade_type, start_time.elapsed());
+            println!(" [{:width$}] {} confirmed: {:?}", "lightspeed", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
 
         Ok(())

src/swqos/mod.rs

@@ -111,6 +111,28 @@ pub enum SwqosType {
 }
 
 impl SwqosType {
+    /// Label for log alignment; same as Debug output (e.g. "Soyas", "Speedlanding").
+    #[inline]
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Jito => "Jito",
+            Self::NextBlock => "NextBlock",
+            Self::ZeroSlot => "ZeroSlot",
+            Self::Temporal => "Temporal",
+            Self::Bloxroute => "Bloxroute",
+            Self::Node1 => "Node1",
+            Self::FlashBlock => "FlashBlock",
+            Self::BlockRazor => "BlockRazor",
+            Self::Astralane => "Astralane",
+            Self::Stellium => "Stellium",
+            Self::Lightspeed => "Lightspeed",
+            Self::Soyas => "Soyas",
+            Self::Speedlanding => "Speedlanding",
+            Self::Helius => "Helius",
+            Self::Default => "Default",
+        }
+    }
+
     pub fn values() -> Vec<Self> {
         vec![
             Self::Jito,

src/swqos/nextblock.rs

@@ -99,12 +99,12 @@ impl NextBlockClient {
 
         if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
             if response_json.get("result").is_some() {
-                println!(" [nextblock] {} submitted: {:?}", trade_type, start_time.elapsed());
+                crate::common::sdk_log::log_swqos_submitted("nextblock", trade_type, start_time.elapsed());
             } else if let Some(_error) = response_json.get("error") {
-                eprintln!(" [nextblock] {} submission failed: {:?}", trade_type, _error);
+                crate::common::sdk_log::log_swqos_submission_failed("nextblock", trade_type, start_time.elapsed(), _error);
             }
         } else {
-            eprintln!(" [nextblock] {} submission failed: {:?}", trade_type, response_text);
+            crate::common::sdk_log::log_swqos_submission_failed("nextblock", trade_type, start_time.elapsed(), response_text);
         }
 
         let start_time: Instant = Instant::now();
@@ -113,16 +113,18 @@ impl NextBlockClient {
             Err(e) => {
                 println!(" signature: {:?}", signature);
                 println!(
-                    " [nextblock] {} confirmation failed: {:?}",
+                    " [{:width$}] {} confirmation failed: {:?}",
+                    "nextblock",
                     trade_type,
-                    start_time.elapsed()
+                    start_time.elapsed(),
+                    width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
                 );
                 return Err(e);
             }
         }
         if wait_confirmation {
             println!(" signature: {:?}", signature);
-            println!(" [nextblock] {} confirmed: {:?}", trade_type, start_time.elapsed());
+            println!(" [{:width$}] {} confirmed: {:?}", "nextblock", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
 
         Ok(())

src/swqos/node1.rs

@@ -184,13 +184,13 @@ impl Node1Client {
         if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
             if crate::common::sdk_log::sdk_log_enabled() {
                 if response_json.get("result").is_some() {
-                    println!(" [node1] {} submitted: {:?}", trade_type, start_time.elapsed());
+                    crate::common::sdk_log::log_swqos_submitted("node1", trade_type, start_time.elapsed());
                 } else if let Some(_error) = response_json.get("error") {
-                    eprintln!(" [node1] {} submission failed: {:?}", trade_type, _error);
+                    eprintln!(" [node1] {} submission failed after {:?}: {:?}", trade_type, start_time.elapsed(), _error);
                 }
             }
         } else if crate::common::sdk_log::sdk_log_enabled() {
-            eprintln!(" [node1] {} submission failed: {:?}", trade_type, response_text);
+            crate::common::sdk_log::log_swqos_submission_failed("node1", trade_type, start_time.elapsed(), response_text);
         }
 
         let start_time: Instant = Instant::now();
@@ -200,9 +200,11 @@ impl Node1Client {
                 if crate::common::sdk_log::sdk_log_enabled() {
                     println!(" signature: {:?}", signature);
                     println!(
-                        " [node1] {} confirmation failed: {:?}",
+                        " [{:width$}] {} confirmation failed: {:?}",
+                        "node1",
                         trade_type,
-                        start_time.elapsed()
+                        start_time.elapsed(),
+                        width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
                     );
                 }
                 return Err(e);
@@ -210,7 +212,7 @@ impl Node1Client {
         }
         if wait_confirmation && crate::common::sdk_log::sdk_log_enabled() {
             println!(" signature: {:?}", signature);
-            println!(" [node1] {} confirmed: {:?}", trade_type, start_time.elapsed());
+            println!(" [{:width$}] {} confirmed: {:?}", "node1", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
 
         Ok(())

src/swqos/soyas.rs

@@ -109,25 +109,35 @@ impl SwqosClientTrait for SoyasClient {
         let serialized_tx = bincode::serialize(transaction)?;
         let connection = self.connection.load_full();
         if Self::try_send_bytes(&connection, &serialized_tx).await.is_err() {
-            eprintln!(" [soyas] {} submission failed, reconnecting", trade_type);
+            if crate::common::sdk_log::sdk_log_enabled() {
+                    crate::common::sdk_log::log_swqos_submission_failed("Soyas", trade_type, start_time.elapsed(), "reconnecting");
+                }
             self.reconnect().await?;
             let connection = self.connection.load_full();
             if let Err(e) = Self::try_send_bytes(&connection, &serialized_tx).await {
-                eprintln!(" [soyas] {} submission failed: {:?}", trade_type, e);
+                if crate::common::sdk_log::sdk_log_enabled() {
+                    crate::common::sdk_log::log_swqos_submission_failed("Soyas", trade_type, start_time.elapsed(), &e);
+                }
                 return Err(e.into());
             }
         }
+        if crate::common::sdk_log::sdk_log_enabled() {
+            crate::common::sdk_log::log_swqos_submitted("Soyas", trade_type, start_time.elapsed());
+        }
+        let start_time = Instant::now();
         match poll_transaction_confirmation(&self.rpc_client, *signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
-                println!(" signature: {:?}", signature);
-                println!(" [soyas] {} confirmation failed: {:?}", trade_type, start_time.elapsed());
+                if crate::common::sdk_log::sdk_log_enabled() {
+                    println!(" signature: {:?}", signature);
+                    println!(" [{:width$}] {} confirmation failed: {:?}", "Soyas", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
+                }
                 return Err(e);
             }
         }
-        if wait_confirmation {
+        if wait_confirmation && crate::common::sdk_log::sdk_log_enabled() {
             println!(" signature: {:?}", signature);
-            println!(" [soyas] {} confirmed: {:?}", trade_type, start_time.elapsed());
+            println!(" [{:width$}] {} confirmed: {:?}", "Soyas", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
         Ok(())
     }

src/swqos/speedlanding.rs

@@ -161,22 +161,42 @@ impl SwqosClientTrait for SpeedlandingClient {
         };
         if need_retry {
             if crate::common::sdk_log::sdk_log_enabled() {
-                eprintln!(" [speedlanding] {} send failed or timeout, reconnecting", trade_type);
+                eprintln!(" [Speedlanding] {} submission failed after {:?}, reconnecting", trade_type, start_time.elapsed());
             }
             let connection = self.ensure_connected().await?;
             send_result =
                 timeout(SEND_TIMEOUT, Self::try_send_bytes(&connection, &*buf_guard)).await;
         }
-        send_result.context("Speedlanding QUIC send timeout")??;
+        match send_result.context("Speedlanding QUIC send timeout") {
+            Ok(Ok(())) => {
+                if crate::common::sdk_log::sdk_log_enabled() {
+                    crate::common::sdk_log::log_swqos_submitted("Speedlanding", trade_type, start_time.elapsed());
+                }
+            }
+            Ok(Err(e)) => {
+                if crate::common::sdk_log::sdk_log_enabled() {
+                    crate::common::sdk_log::log_swqos_submission_failed("Speedlanding", trade_type, start_time.elapsed(), &e);
+                }
+                return Err(e.into());
+            }
+            Err(e) => {
+                if crate::common::sdk_log::sdk_log_enabled() {
+                    crate::common::sdk_log::log_swqos_submission_failed("Speedlanding", trade_type, start_time.elapsed(), "timeout");
+                }
+                return Err(e.into());
+            }
+        }
         match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 if crate::common::sdk_log::sdk_log_enabled() {
                     println!(" signature: {:?}", signature);
                     println!(
-                        " [speedlanding] {} confirmation failed: {:?}",
+                        " [{:width$}] {} confirmation failed: {:?}",
+                        "Speedlanding",
                         trade_type,
-                        start_time.elapsed()
+                        start_time.elapsed(),
+                        width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
                     );
                 }
                 return Err(e);
@@ -184,7 +204,7 @@ impl SwqosClientTrait for SpeedlandingClient {
         }
         if wait_confirmation && crate::common::sdk_log::sdk_log_enabled() {
             println!(" signature: {:?}", signature);
-            println!(" [speedlanding] {} confirmed: {:?}", trade_type, start_time.elapsed());
+            println!(" [{:width$}] {} confirmed: {:?}", "Speedlanding", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
         Ok(())
     }

src/swqos/stellium.rs

@@ -168,13 +168,13 @@ impl StelliumClient {
         if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
             if crate::common::sdk_log::sdk_log_enabled() {
                 if response_json.get("result").is_some() {
-                    println!(" [Stellium] {} submitted: {:?}", trade_type, start_time.elapsed());
+                    crate::common::sdk_log::log_swqos_submitted("Stellium", trade_type, start_time.elapsed());
                 } else if let Some(_error) = response_json.get("error") {
-                    eprintln!(" [Stellium] {} submission failed: {:?}", trade_type, _error);
+                    crate::common::sdk_log::log_swqos_submission_failed("Stellium", trade_type, start_time.elapsed(), _error);
                 }
             }
         } else if crate::common::sdk_log::sdk_log_enabled() {
-            eprintln!(" [Stellium] {} submission failed: {:?}", trade_type, response_text);
+            crate::common::sdk_log::log_swqos_submission_failed("Stellium", trade_type, start_time.elapsed(), response_text);
         }
 
         let start_time: Instant = Instant::now();
@@ -184,9 +184,11 @@ impl StelliumClient {
                 if crate::common::sdk_log::sdk_log_enabled() {
                     println!(" signature: {:?}", signature);
                     println!(
-                        " [Stellium] {} confirmation failed: {:?}",
+                        " [{:width$}] {} confirmation failed: {:?}",
+                        "Stellium",
                         trade_type,
-                        start_time.elapsed()
+                        start_time.elapsed(),
+                        width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
                     );
                 }
                 return Err(e);
@@ -194,7 +196,7 @@ impl StelliumClient {
         }
         if wait_confirmation && crate::common::sdk_log::sdk_log_enabled() {
             println!(" signature: {:?}", signature);
-            println!(" [Stellium] {} confirmed: {:?}", trade_type, start_time.elapsed());
+            println!(" [{:width$}] {} confirmed: {:?}", "Stellium", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
 
         Ok(())

src/swqos/temporal.rs

@@ -209,12 +209,12 @@ impl TemporalClient {
 
         if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
             if response_json.get("result").is_some() {
-                println!(" [nozomi] {} submitted: {:?}", trade_type, start_time.elapsed());
+                crate::common::sdk_log::log_swqos_submitted("nozomi", trade_type, start_time.elapsed());
             } else if let Some(_error) = response_json.get("error") {
-                // eprintln!("nozomi transaction submission failed: {:?}", _error);
+                crate::common::sdk_log::log_swqos_submission_failed("nozomi", trade_type, start_time.elapsed(), _error);
             }
         } else {
-            eprintln!(" [nozomi] {} submission failed: {:?}", trade_type, response_text);
+            crate::common::sdk_log::log_swqos_submission_failed("nozomi", trade_type, start_time.elapsed(), response_text);
         }
 
         let start_time: Instant = Instant::now();
@@ -232,7 +232,7 @@ impl TemporalClient {
         }
         if wait_confirmation {
             println!(" signature: {:?}", signature);
-            println!(" [nozomi] {} confirmed: {:?}", trade_type, start_time.elapsed());
+            println!(" [{:width$}] {} confirmed: {:?}", "nozomi", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
 
         Ok(())

src/swqos/zeroslot.rs

@@ -102,12 +102,12 @@ impl ZeroSlotClient {
         // 5. Use `serde_json::from_str()` to parse JSON, reducing extra wait from `.json().await?`
         if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
             if response_json.get("result").is_some() {
-                println!(" [0slot] {} submitted: {:?}", trade_type, start_time.elapsed());
+                crate::common::sdk_log::log_swqos_submitted("0slot", trade_type, start_time.elapsed());
             } else if let Some(_error) = response_json.get("error") {
-                eprintln!(" [0slot] {} submission failed: {:?}", trade_type, _error);
+                eprintln!(" [0slot] {} submission failed after {:?}: {:?}", trade_type, start_time.elapsed(), _error);
             }
         } else {
-            eprintln!(" [0slot] {} submission failed: {:?}", trade_type, response_text);
+            crate::common::sdk_log::log_swqos_submission_failed("0slot", trade_type, start_time.elapsed(), response_text);
         }
 
         let start_time: Instant = Instant::now();
@@ -115,13 +115,13 @@ impl ZeroSlotClient {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
-                println!(" [0slot] {} confirmation failed: {:?}", trade_type, start_time.elapsed());
+                println!(" [{:width$}] {} confirmation failed: {:?}", "0slot", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
                 return Err(e);
             }
         }
         if wait_confirmation {
             println!(" signature: {:?}", signature);
-            println!(" [0slot] {} confirmed: {:?}", trade_type, start_time.elapsed());
+            println!(" [{:width$}] {} confirmed: {:?}", "0slot", trade_type, start_time.elapsed(), width = crate::common::sdk_log::SWQOS_LABEL_WIDTH);
         }
 
         Ok(())

src/trading/common/transaction_builder.rs

@@ -25,8 +25,8 @@ fn sol_f64_to_lamports(sol: f64) -> u64 {
     (lamports.min(u64::MAX as f64)).round() as u64
 }
 
-/// Build standard RPC transaction.
-/// Takes Arc/context by reference to avoid clone in worker hot path (Arc::clone is cheap but ref is zero-cost).
+/// Build standard RPC transaction (worker hot path).
+/// Takes Arc/refs only; one Vec allocation (with_capacity), extend_from_slice for business_instructions, no extra clone of payer/rpc/middleware.
 pub async fn build_transaction(
     payer: &Arc<Keypair>,
     _rpc: Option<&Arc<SolanaRpcClient>>,

src/trading/core/async_executor.rs

@@ -1,9 +1,15 @@
 //! Parallel executor for multi-SWQOS submit.
 //!
+//! **Hot path (submit):** no lock (OnceCell + lock-free ArrayQueue), no `get_core_ids()`, only Arc clones and queue push.
 //! - **Pool**: Pre-spawned workers (default 18); hot path only enqueues jobs (no per-call tokio::spawn).
-//! - **Dedicated threads** (opt-in via TradeConfig): When `use_dedicated_sender_threads` is true, N OS threads (default 18) run sender work only, optionally pinned to cores via `sender_thread_cores`, reducing scheduling contention when sending many txs.
-//! - **Arc**: Shared data is behind `Arc` so "clone" is just a refcount increment (no data copy).
-//! - **Refs**: `build_transaction` takes `&Arc<..>`, `Option<&DurableNonceInfo>`, `Option<&AddressLookupTableAccount>` so the worker passes refs only (zero clone on worker path).
+//! - **Dedicated threads** (opt-in via `with_dedicated_sender_threads`): N OS threads run sender work only, optionally pinned to cores.
+//! - **Arc**: Shared data behind `Arc` → clone = refcount increment (no data copy).
+//! - **Refs**: `build_transaction` takes refs only; worker path avoids extra clones.
+//!
+//! **Core affinity & latency:** Each job is assigned a core (round-robin from `effective_core_ids`). When a worker runs a job,
+//! it sets thread affinity to that core. If that core is busy with other work (e.g. node sync, bot logic), SWQOS submit on that
+//! core will compete for CPU and latency can increase. For lowest latency, reserve a subset of cores for SWQOS only via
+//! `with_dedicated_sender_threads(Some(indices))` and avoid running other CPU-heavy work on those core indices.
 
 use anyhow::{anyhow, Result};
 use crossbeam_queue::ArrayQueue;
@@ -15,8 +21,8 @@ use solana_sdk::{
 };
 use std::collections::HashMap;
 use std::hash::BuildHasherDefault;
+use parking_lot::Mutex;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
-use std::sync::Mutex;
 use std::{str::FromStr, sync::Arc, time::Instant};
 use tokio::sync::Notify;
 
@@ -28,6 +34,7 @@ use crate::{
     common::nonce_cache::DurableNonceInfo,
     common::{GasFeeStrategy, SolanaRpcClient},
     swqos::{SwqosClient, SwqosType, TradeType},
+    trading::core::params::SenderConcurrencyConfig,
     trading::{common::build_transaction, MiddlewareManager},
 };
 
@@ -154,28 +161,35 @@ static DEDICATED_NOTIFY: OnceCell<Arc<Notify>> = OnceCell::new();
 /// JoinHandles kept so dedicated threads are not detached; only touched during init under lock.
 static DEDICATED_INIT: Mutex<Option<Vec<std::thread::JoinHandle<()>>>> = Mutex::new(None);
 
-fn ensure_dedicated_pool(sender_thread_cores: Option<&[usize]>) -> (Arc<ArrayQueue<SwqosJob>>, Arc<Notify>) {
+fn ensure_dedicated_pool(
+    sender_thread_cores: Option<&[usize]>,
+    max_sender_concurrency: usize,
+) -> (Arc<ArrayQueue<SwqosJob>>, Arc<Notify>) {
     if let (Some(q), Some(n)) = (DEDICATED_QUEUE.get(), DEDICATED_NOTIFY.get()) {
         return (q.clone(), n.clone());
     }
-    let mut guard = DEDICATED_INIT.lock().expect("dedicated init mutex");
+    let mut guard = DEDICATED_INIT.lock();
     if let (Some(q), Some(n)) = (DEDICATED_QUEUE.get(), DEDICATED_NOTIFY.get()) {
         return (q.clone(), n.clone());
     }
     let n = sender_thread_cores
-        .map(|v| v.len())
-        .unwrap_or(SWQOS_DEDICATED_DEFAULT_THREADS)
-        .min(32);
+        .map(|v| v.len().min(max_sender_concurrency))
+        .unwrap_or_else(|| SWQOS_DEDICATED_DEFAULT_THREADS.min(max_sender_concurrency))
+        .min(32)
+        .max(1);
     let queue = Arc::new(ArrayQueue::new(SWQOS_QUEUE_CAP));
     let notify = Arc::new(Notify::new());
-    let core_ids: Vec<core_affinity::CoreId> = sender_thread_cores
-        .and_then(|indices| {
-            core_affinity::get_core_ids().map(|ids| {
-                indices
-                    .iter()
-                    .filter_map(|&i| ids.get(i).cloned())
-                    .collect()
-            })
+    let core_ids: Vec<core_affinity::CoreId> = core_affinity::get_core_ids()
+        .map(|all_ids| {
+            sender_thread_cores
+                .map(|indices| {
+                    indices
+                        .iter()
+                        .take(n)
+                        .filter_map(|&i| all_ids.get(i).cloned())
+                        .collect()
+                })
+                .unwrap_or_else(|| all_ids.into_iter().take(n).collect())
         })
         .unwrap_or_default();
     let mut handles = Vec::with_capacity(n);
@@ -201,12 +215,13 @@ fn ensure_dedicated_pool(sender_thread_cores: Option<&[usize]>) -> (Arc<ArrayQue
     (queue, notify)
 }
 
-fn ensure_swqos_pool(queue: Arc<ArrayQueue<SwqosJob>>) {
+fn ensure_swqos_pool(queue: Arc<ArrayQueue<SwqosJob>>, max_sender_concurrency: usize) {
     if SWQOS_WORKERS_STARTED.swap(true, Ordering::AcqRel) {
         return;
     }
+    let n = SWQOS_POOL_WORKERS.min(max_sender_concurrency).max(1);
     let notify = SWQOS_NOTIFY.get_or_init(|| Arc::new(Notify::new())).clone();
-    for _ in 0..SWQOS_POOL_WORKERS {
+    for _ in 0..n {
         tokio::spawn(swqos_worker_loop(queue.clone(), notify.clone()));
     }
 }
@@ -400,6 +415,8 @@ impl ResultCollector {
 }
 
 /// Execute trade on multiple SWQOS clients in parallel; returns success flag, all signatures, and last error.
+///
+/// `sender_config` merges sender_thread_cores, effective_core_ids, max_sender_concurrency (precomputed at SDK init; no get_core_ids on hot path).
 pub async fn execute_parallel(
     swqos_clients: &[Arc<SwqosClient>],
     payer: Arc<Keypair>,
@@ -414,13 +431,10 @@ pub async fn execute_parallel(
     wait_transaction_confirmed: bool,
     with_tip: bool,
     gas_fee_strategy: GasFeeStrategy,
-    use_core_affinity: bool,
     use_dedicated_sender_threads: bool,
-    sender_thread_cores: Option<&[usize]>,
+    sender_config: SenderConcurrencyConfig,
     check_min_tip: bool,
 ) -> Result<(bool, Vec<Signature>, Option<anyhow::Error>, Vec<(SwqosType, i64)>)> {
-    let _exec_start = Instant::now();
-
     if swqos_clients.is_empty() {
         return Err(anyhow!("swqos_clients is empty"));
     }
@@ -434,44 +448,40 @@ pub async fn execute_parallel(
         return Err(anyhow!("No Rpc Default Swqos configured."));
     }
 
-    let cores = core_affinity::get_core_ids().unwrap_or_default();
     let instructions = Arc::new(instructions);
 
-    // Precompute all valid (client, gas config) combinations
-    let task_configs: Vec<_> = swqos_clients
-        .iter()
-        .enumerate()
-        .filter(|(_, swqos_client)| {
-            with_tip || matches!(swqos_client.get_swqos_type(), SwqosType::Default)
-        })
-        .flat_map(|(i, swqos_client)| {
-            let swqos_type = swqos_client.get_swqos_type();
-            let gas_fee_strategy_configs = gas_fee_strategy.get_strategies(if is_buy {
-                TradeType::Buy
-            } else {
-                TradeType::Sell
-            });
-            let check_tip = with_tip && !matches!(swqos_type, SwqosType::Default) && check_min_tip;
-            let min_tip = if check_tip { swqos_client.min_tip_sol() } else { 0.0 };
-            gas_fee_strategy_configs
-                .into_iter()
-                .filter(move |config| config.0 == swqos_type)
-                .filter(move |config| {
-                    if check_tip {
-                        if config.2.tip < min_tip && crate::common::sdk_log::sdk_log_enabled() {
-                            println!(
-                                "⚠️ Config filtered: {:?} tip {} is below minimum required {}",
-                                config.0, config.2.tip, min_tip
-                            );
-                        }
-                        config.2.tip >= min_tip
-                    } else {
-                        true
-                    }
-                })
-                .map(move |config| (i, swqos_client.clone(), config))
-        })
-        .collect();
+    // One get_strategies call per batch (avoid N calls in loop).
+    let gas_fee_configs = gas_fee_strategy.get_strategies(if is_buy {
+        TradeType::Buy
+    } else {
+        TradeType::Sell
+    });
+    let mut task_configs = Vec::with_capacity(swqos_clients.len() * 3);
+    for (i, swqos_client) in swqos_clients.iter().enumerate() {
+        if !with_tip && !matches!(swqos_client.get_swqos_type(), SwqosType::Default) {
+            continue;
+        }
+        let swqos_type = swqos_client.get_swqos_type();
+        let check_tip = with_tip && !matches!(swqos_type, SwqosType::Default) && check_min_tip;
+        let min_tip = if check_tip { swqos_client.min_tip_sol() } else { 0.0 };
+        for config in &gas_fee_configs {
+            if config.0 != swqos_type {
+                continue;
+            }
+            if check_tip {
+                if config.2.tip < min_tip && crate::common::sdk_log::sdk_log_enabled() {
+                    println!(
+                        "⚠️ Config filtered: {:?} tip {} is below minimum required {}",
+                        config.0, config.2.tip, min_tip
+                    );
+                }
+                if config.2.tip < min_tip {
+                    continue;
+                }
+            }
+            task_configs.push((i, swqos_client.clone(), *config));
+        }
+    }
 
     if task_configs.is_empty() {
         return Err(anyhow!("No available gas fee strategy configs"));
@@ -499,23 +509,27 @@ pub async fn execute_parallel(
     });
 
     let (queue, notify) = if use_dedicated_sender_threads {
-        ensure_dedicated_pool(sender_thread_cores)
+        ensure_dedicated_pool(
+            sender_config.sender_thread_cores.as_ref().map(|a| a.as_slice()),
+            sender_config.max_sender_concurrency,
+        )
     } else {
         let q = SWQOS_QUEUE.get_or_init(|| Arc::new(ArrayQueue::new(SWQOS_QUEUE_CAP)));
-        ensure_swqos_pool(q.clone());
+        ensure_swqos_pool(q.clone(), sender_config.max_sender_concurrency);
         (q.clone(), SWQOS_NOTIFY.get_or_init(|| Arc::new(Notify::new())).clone())
     };
 
     {
-        // Cache tip_account per client (one get_tip_account/from_str per unique client per batch). Dropped before await so future stays Send.
+        let effective_core_ids = sender_config.effective_core_ids.as_slice();
+        let core_len = effective_core_ids.len().max(1);
         let mut tip_cache: FnvHashMap<*const (), Arc<Pubkey>> =
             FnvHashMap::with_capacity_and_hasher(task_configs.len(), BuildHasherDefault::default());
         for (i, swqos_client, gas_fee_strategy_config) in task_configs {
-            let core_id = cores.get(i % cores.len().max(1)).copied();
+            let core_id = effective_core_ids.get(i % core_len).copied();
             let swqos_type = swqos_client.get_swqos_type();
             let key = Arc::as_ptr(&swqos_client) as *const ();
             let tip_account = match tip_cache.get(&key) {
-                Some(tip) => tip.clone(),
+                Some(t) => t.clone(),
                 None => {
                     let s = swqos_client.get_tip_account()?;
                     let tip = Arc::new(Pubkey::from_str(&s).unwrap_or_default());
@@ -537,7 +551,7 @@ pub async fn execute_parallel(
                 swqos_client,
                 swqos_type,
                 core_id,
-                use_affinity: use_core_affinity,
+                use_affinity: !effective_core_ids.is_empty(),
             };
             let _ = queue.push(job);
         }

src/trading/core/executor.rs

@@ -118,32 +118,46 @@ impl TradeExecutor for GenericTradeExecutor {
 
             if crate::common::sdk_log::sdk_log_enabled() {
                 let dir = if is_buy { "Buy" } else { "Sell" };
+                println!();
                 if let (Some(start_us), Some(end_us)) = (timing_start_us, build_end_us) {
                     println!(
-                        " [SDK] {} build_instructions: {:.4} ms",
+                        " [SDK][{:width$}] {} build_instructions: {:.4} ms",
+                        "-",
                         dir,
-                        (end_us - start_us) as f64 / 1000.0
+                        (end_us - start_us) as f64 / 1000.0,
+                        width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
                     );
                 }
                 if let (Some(start_us), Some(end_us)) = (timing_start_us, before_submit_us) {
                     println!(
-                        " [SDK] {} before_submit: {:.4} ms",
+                        " [SDK][{:width$}] {} before_submit: {:.4} ms",
+                        "-",
                         dir,
-                        (end_us - start_us) as f64 / 1000.0
+                        (end_us - start_us) as f64 / 1000.0,
+                        width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
                     );
                 }
                 println!(
-                    " [SDK] {} simulate (dry-run): {:.4} ms",
+                    " [SDK][{:width$}] {} simulate (dry-run): {:.4} ms",
+                    "-",
                     dir,
-                    send_elapsed.as_secs_f64() * 1000.0
+                    send_elapsed.as_secs_f64() * 1000.0,
+                    width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
+                );
+                println!(
+                    " [SDK][{:width$}] {} total: {:.4} ms",
+                    "-",
+                    dir,
+                    total_elapsed.as_secs_f64() * 1000.0,
+                    width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
                 );
-                println!(" [SDK] {} total: {:.4} ms", dir, total_elapsed.as_secs_f64() * 1000.0);
             }
 
             return result;
         }
 
-        let need_confirm = params.wait_transaction_confirmed;
+        let need_confirm = params.wait_tx_confirmed;
+        let sender_config = params.sender_concurrency_config();
         let result = execute_parallel(
             params.swqos_clients.as_slice(),
             params.payer,
@@ -158,9 +172,8 @@ impl TradeExecutor for GenericTradeExecutor {
             false, // submit only here; confirmation and log timing handled below
             if is_buy { true } else { params.with_tip },
             params.gas_fee_strategy,
-            params.use_core_affinity,
             params.use_dedicated_sender_threads,
-            params.sender_thread_cores.as_ref().map(|a| a.as_slice()),
+            sender_config,
             params.check_min_tip,
         )
         .await;
@@ -185,32 +198,14 @@ impl TradeExecutor for GenericTradeExecutor {
                     let confirm_done_us = log_enabled.then(crate::common::clock::now_micros);
                     if log_enabled {
                         let dir = if is_buy { "Buy" } else { "Sell" };
-                        if let Some(start_us) = timing_start_us {
-                            if let Some(end_us) = build_end_us {
-                                println!(
-                                    " [SDK] {} build_instructions: {:.4} ms",
-                                    dir,
-                                    (end_us - start_us) as f64 / 1000.0
-                                );
-                            }
-                            if let Some(end_us) = before_submit_us {
-                                println!(
-                                    " [SDK] {} before_submit: {:.4} ms",
-                                    dir,
-                                    (end_us - start_us) as f64 / 1000.0
-                                );
-                            }
-                            if let Some(confirm_us) = confirm_done_us {
-                                let total_ms = (confirm_us - start_us) as f64 / 1000.0;
-                                for (swqos_type, submit_done_us) in submit_timings_ref {
-                                    let submit_ms =
-                                        (*submit_done_us - start_us).max(0) as f64 / 1000.0;
-                                    let confirmed_ms =
-                                        (confirm_us - *submit_done_us).max(0) as f64 / 1000.0;
-                                    println!(" [SDK] {} {:?} submit: {:.4} ms, confirmed: {:.4} ms, total: {:.4} ms", dir, swqos_type, submit_ms, confirmed_ms, total_ms);
-                                }
-                            }
-                        }
+                        crate::common::sdk_log::print_sdk_timing_block(
+                            dir,
+                            timing_start_us,
+                            build_end_us,
+                            before_submit_us,
+                            submit_timings_ref,
+                            confirm_done_us,
+                        );
                     }
                     match poll_res {
                         Ok(_) => (true, signatures, None),
@@ -222,31 +217,17 @@ impl TradeExecutor for GenericTradeExecutor {
             };
             Ok(confirm_result)
         } else {
+            // Not waiting for confirmation: confirmed is not measured (-); total is per-channel submit time only.
             if log_enabled {
                 let dir = if is_buy { "Buy" } else { "Sell" };
-                if let Some(start_us) = timing_start_us {
-                    if let Some(end_us) = build_end_us {
-                        println!(
-                            " [SDK] {} build_instructions: {:.4} ms",
-                            dir,
-                            (end_us - start_us) as f64 / 1000.0
-                        );
-                    }
-                    if let Some(end_us) = before_submit_us {
-                        println!(
-                            " [SDK] {} before_submit: {:.4} ms",
-                            dir,
-                            (end_us - start_us) as f64 / 1000.0
-                        );
-                    }
-                    for (swqos_type, submit_done_us) in submit_timings_ref {
-                        let submit_ms = (*submit_done_us - start_us).max(0) as f64 / 1000.0;
-                        println!(
-                            " [SDK] {} {:?} submit: {:.4} ms, confirmed: -, total: {:.4} ms",
-                            dir, swqos_type, submit_ms, submit_ms
-                        );
-                    }
-                }
+                crate::common::sdk_log::print_sdk_timing_block(
+                    dir,
+                    timing_start_us,
+                    build_end_us,
+                    before_submit_us,
+                    submit_timings_ref,
+                    None,
+                );
             }
             Ok((ok, signatures, err))
         };
@@ -377,37 +358,47 @@ mod tests {
         let dir = "Buy";
         let build_ms = 12.34;
         let before_submit_ms = 15.67;
+        let w = 12usize; // same as crate::common::sdk_log::SWQOS_LABEL_WIDTH
         println!("\n--- 1. 构建指令耗时 / 提交前耗时（各打印一次，统一 ms，保留 4 位小数）---\n");
-        println!(" [SDK] {} build_instructions: {:.4} ms", dir, build_ms);
-        println!(" [SDK] {} before_submit: {:.4} ms", dir, before_submit_ms);
+        println!(" [SDK][{:width$}] {} build_instructions: {:.4} ms", "-", dir, build_ms, width = w);
+        println!(" [SDK][{:width$}] {} before_submit: {:.4} ms", "-", dir, before_submit_ms, width = w);
 
-        println!("\n--- 2. 每个 SWQOS 独立耗时：submit=起点→该通道返回, confirmed=该通道提交→链上确认, total=起点→链上确认 ---\n");
+        println!("\n--- 2. 每个 SWQOS 独立耗时：submit_done=起点→该通道提交完成, confirmed=该通道提交→链上确认, total=起点→链上确认 ---\n");
         for (swqos_type, submit_ms, confirmed_ms, total_ms) in [
             (SwqosType::Jito, 45.12, 83.38, 128.50),
             (SwqosType::Helius, 52.30, 76.20, 128.50),
             (SwqosType::ZeroSlot, 48.90, 79.60, 128.50),
         ] {
             println!(
-                " [SDK] {} {:?} submit: {:.4} ms, confirmed: {:.4} ms, total: {:.4} ms",
-                dir, swqos_type, submit_ms, confirmed_ms, total_ms
+                " [SDK][{:width$}] {} submit_done: {:.4} ms, confirmed: {:.4} ms, total: {:.4} ms",
+                swqos_type.as_str(),
+                dir,
+                submit_ms,
+                confirmed_ms,
+                total_ms,
+                width = w
             );
         }
 
-        println!("\n--- 3. 不等待链上确认时：每行 total = 该通道 submit 耗时（独立）---\n");
+        println!("\n--- 3. 不等待链上确认时：每行 total = 该通道 submit_done（提交完成总耗时）---\n");
         for (swqos_type, submit_ms, total_ms) in
             [(SwqosType::Jito, 44.20, 44.20), (SwqosType::Helius, 51.80, 51.80)]
         {
             println!(
-                " [SDK] {} {:?} submit: {:.4} ms, confirmed: -, total: {:.4} ms",
-                dir, swqos_type, submit_ms, total_ms
+                " [SDK][{:width$}] {} submit_done: {:.4} ms, confirmed: -, total: {:.4} ms",
+                swqos_type.as_str(),
+                dir,
+                submit_ms,
+                total_ms,
+                width = w
             );
         }
 
         println!("\n--- 4. Simulate 模式（build/before_submit 仍从 grpc_recv_us 起算）---\n");
-        println!(" [SDK] {} build_instructions: {:.4} ms", dir, build_ms);
-        println!(" [SDK] {} before_submit: {:.4} ms", dir, before_submit_ms);
-        println!(" [SDK] {} simulate (dry-run): {:.4} ms", dir, 8.50);
-        println!(" [SDK] {} total: {:.4} ms", dir, 36.51);
+        println!(" [SDK][{:width$}] {} build_instructions: {:.4} ms", "-", dir, build_ms, width = w);
+        println!(" [SDK][{:width$}] {} before_submit: {:.4} ms", "-", dir, before_submit_ms, width = w);
+        println!(" [SDK][{:width$}] {} simulate (dry-run): {:.4} ms", "-", dir, 8.50, width = w);
+        println!(" [SDK][{:width$}] {} total: {:.4} ms", "-", dir, 36.51, width = w);
         println!();
     }
 }

src/trading/core/params.rs

@@ -3,7 +3,16 @@ use crate::common::nonce_cache::DurableNonceInfo;
 use crate::common::spl_associated_token_account::get_associated_token_address_with_program_id;
 use crate::common::{GasFeeStrategy, SolanaRpcClient};
 use crate::constants::TOKEN_PROGRAM;
+use core_affinity::CoreId;
 use crate::instruction::utils::pumpfun::global_constants::MAYHEM_FEE_RECIPIENT;
+
+/// Concurrency + core binding config for parallel submit (precomputed at SDK init, one param on hot path). Uses Arc so no borrow of SwapParams.
+#[derive(Clone)]
+pub struct SenderConcurrencyConfig {
+    pub sender_thread_cores: Option<Arc<Vec<usize>>>,
+    pub effective_core_ids: Arc<Vec<CoreId>>,
+    pub max_sender_concurrency: usize,
+}
 use crate::instruction::utils::pumpswap::accounts::MAYHEM_FEE_RECIPIENT as MAYHEM_FEE_RECIPIENT_SWAP;
 use crate::swqos::{SwqosClient, TradeType};
 use crate::trading::common::get_multi_token_balances;
@@ -53,7 +62,7 @@ pub struct SwapParams {
     pub slippage_basis_points: Option<u64>,
     pub address_lookup_table_account: Option<AddressLookupTableAccount>,
     pub recent_blockhash: Option<Hash>,
-    pub wait_transaction_confirmed: bool,
+    pub wait_tx_confirmed: bool,
     pub protocol_params: DexParamEnum,
     pub open_seed_optimize: bool,
     /// Arc<Vec<..>> so cloning from infrastructure is a single Arc clone.
@@ -70,12 +79,14 @@ pub struct SwapParams {
     pub simulate: bool,
     /// Whether to output SDK logs (from TradeConfig.log_enabled).
     pub log_enabled: bool,
-    /// Whether to pin parallel submit tasks to cores (from TradeConfig.use_core_affinity).
-    pub use_core_affinity: bool,
-    /// Use dedicated sender threads (from TradeConfig.use_dedicated_sender_threads).
+    /// Use dedicated sender threads (internal; set via client.with_dedicated_sender_threads()).
     pub use_dedicated_sender_threads: bool,
     /// Core indices for dedicated sender threads (from TradeConfig.sender_thread_cores). Arc avoids cloning the Vec on hot path.
     pub sender_thread_cores: Option<Arc<Vec<usize>>>,
+    /// Precomputed at SDK init: min(swqos_count, 2/3*cores). Avoids get_core_ids() on trade hot path.
+    pub max_sender_concurrency: usize,
+    /// Precomputed at SDK init: first max_sender_concurrency CoreIds for job affinity. Arc clone only.
+    pub effective_core_ids: Arc<Vec<CoreId>>,
     /// Whether to check minimum tip per SWQOS (from TradeConfig.check_min_tip). When false, skip filter for lower latency.
     pub check_min_tip: bool,
     /// Optional event receive time in microseconds (same scale as sol-parser-sdk clock::now_micros). Used as timing start when log_enabled.
@@ -87,6 +98,18 @@ pub struct SwapParams {
     pub use_exact_sol_amount: Option<bool>,
 }
 
+impl SwapParams {
+    /// One struct for execute_parallel: merges sender_thread_cores, effective_core_ids, max_sender_concurrency. Arc clone only.
+    #[inline]
+    pub fn sender_concurrency_config(&self) -> SenderConcurrencyConfig {
+        SenderConcurrencyConfig {
+            sender_thread_cores: self.sender_thread_cores.clone(),
+            effective_core_ids: self.effective_core_ids.clone(),
+            max_sender_concurrency: self.max_sender_concurrency,
+        }
+    }
+}
+
 impl std::fmt::Debug for SwapParams {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "SwapParams: ...")