feat(core): simulate realistic network conditions

Signed-off-by: AvhiMaz <avhimazumder5@outlook.com>

Author: AvhiMaz

Cargo.lock

@@ -63,6 +63,16 @@ lazy_static::lazy_static! {
 /// We set out snap build to set this environment variable to the real home directory,
 /// because by default, snaps run in a confined environment where the home directory is not
 /// the user's actual home directory.
+fn parse_drop_rate(s: &str) -> Result<f64, String> {
+    let v: f64 = s
+        .parse()
+        .map_err(|_| format!("'{}' is not a valid number", s))?;
+    if !(0.0..=1.0).contains(&v) {
+        return Err(format!("drop rate must be between 0.0 and 1.0, got {}", v));
+    }
+    Ok(v)
+}
+
 pub fn get_home_dir() -> String {
     if let Ok(real_home) = env::var("SNAP_REAL_HOME") {
         let path_buf = PathBuf::from(real_home);
@@ -276,6 +286,14 @@ pub struct StartSimnet {
     /// Skip signature verification for all transactions (eg. surfpool start --skip-signature-verification)
     #[clap(long = "skip-signature-verification", action=ArgAction::SetTrue, default_value = "false")]
     pub skip_signature_verification: bool,
+    /// Probability (0.0–1.0) that a transaction is randomly dropped, simulating packet loss or leader rejection.
+    /// E.g. 0.1 means 10% of transactions will be dropped. (eg. surfpool start --transaction-drop-rate 0.1)
+    #[arg(long = "transaction-drop-rate", value_parser = parse_drop_rate)]
+    pub transaction_drop_rate: Option<f64>,
+    /// Maximum random delay in milliseconds before executing a transaction, simulating out-of-order execution.
+    /// Each transaction waits a random duration from 0 to this value. (eg. surfpool start --transaction-execution-delay-ms 200)
+    #[arg(long = "transaction-execution-delay-ms")]
+    pub transaction_execution_delay_ms: Option<u64>,
 }
 
 #[derive(clap::ValueEnum, PartialEq, Clone, Debug)]
@@ -426,6 +444,8 @@ impl StartSimnet {
             skip_signature_verification: self.skip_signature_verification,
             surfnet_id: self.surfnet_id.clone(),
             snapshot,
+            transaction_drop_rate: self.transaction_drop_rate,
+            transaction_execution_delay_ms: self.transaction_execution_delay_ms,
         }
     }
 

crates/cli/src/cli/mod.rs

@@ -42,6 +42,7 @@ libloading = { workspace = true }
 litesvm = { workspace = true }
 litesvm-token = { workspace = true }
 log = { workspace = true }
+rand = "0.8"
 reqwest = { workspace = true }
 serde = { workspace = true }
 serde_derive = { workspace = true }                                  # must match the serde version, see https://github.com/serde-rs/serde/issues/2584#issuecomment-1685252251

crates/core/Cargo.toml

@@ -1679,6 +1679,18 @@ impl Full for SurfpoolFullRpc {
                     m.record_transaction(true, rpc_start.elapsed().as_millis() as u64);
                 }
             }
+            Ok(TransactionStatusEvent::Dropped) => {
+                #[cfg(feature = "prometheus")]
+                if let Some(m) = crate::telemetry::metrics() {
+                    m.record_transaction(false, rpc_start.elapsed().as_millis() as u64);
+                    m.record_rpc_request("sendTransaction", rpc_start.elapsed().as_millis() as u64);
+                }
+                return Err(Error {
+                    data: None,
+                    message: "Transaction dropped: simulated network condition".to_string(),
+                    code: jsonrpc_core::ErrorCode::ServerError(-32002),
+                });
+            }
         }
 
         #[cfg(feature = "prometheus")]

crates/core/src/rpc/full.rs

@@ -346,6 +346,8 @@ pub async fn start_block_production_runloop(
         expiry_duration_ms.map(|expiry_val| Utc::now().timestamp_millis() as u64 + expiry_val);
     let global_skip_sig_verify = simnet_config.skip_signature_verification;
     let ix_profiling_initially_enabled = simnet_config.instruction_profiling_enabled;
+    let transaction_drop_rate = simnet_config.transaction_drop_rate;
+    let transaction_execution_delay_ms = simnet_config.transaction_execution_delay_ms;
     loop {
         let mut do_produce_block = false;
 
@@ -481,6 +483,23 @@ pub async fn start_block_production_runloop(
                         continue
                     }
                     SimnetCommand::ProcessTransaction(_key, transaction, status_tx, skip_preflight, skip_sig_verify_override) => {
+                       // Randomly drop the transaction to simulate real-world packet loss / leader rejection
+                       if let Some(drop_rate) = transaction_drop_rate {
+                           if rand::random::<f64>() < drop_rate {
+                               let _ = svm_locker.simnet_events_tx().send(SimnetEvent::warn(
+                                   format!("Transaction dropped (simulated, drop_rate={})", drop_rate)
+                               ));
+                               let _ = status_tx.send(surfpool_types::TransactionStatusEvent::Dropped);
+                               continue;
+                           }
+                       }
+                       // Apply random execution delay to simulate out-of-order processing
+                       if let Some(max_delay_ms) = transaction_execution_delay_ms {
+                           if max_delay_ms > 0 {
+                                   let delay = rand::random::<u64>() % (max_delay_ms + 1);
+                               tokio::time::sleep(std::time::Duration::from_millis(delay)).await;
+                           }
+                       }
                        let skip_sig_verify = skip_sig_verify_override.unwrap_or(global_skip_sig_verify);
                        let sigverify = !skip_sig_verify;
                        if let Err(e) = svm_locker.process_transaction(&remote_client_with_commitment, transaction, status_tx, skip_preflight, sigverify).await {

crates/core/src/runloops/mod.rs

@@ -825,6 +825,9 @@ async fn test_transaction_with_ed25519_instruction(test_type: TestType) {
         Ok(TransactionStatusEvent::VerificationFailure(error)) => {
             panic!("Transaction verification failed: {}", error);
         }
+        Ok(TransactionStatusEvent::Dropped) => {
+            panic!("Transaction was unexpectedly dropped");
+        }
         Err(e) => {
             panic!("Failed to receive transaction status: {:?}", e);
         }
@@ -1553,6 +1556,9 @@ async fn test_get_transaction_profile(test_type: TestType) {
         Ok(TransactionStatusEvent::VerificationFailure(error)) => {
             panic!("Transaction verification failed: {}", error);
         }
+        Ok(TransactionStatusEvent::Dropped) => {
+            panic!("Transaction was unexpectedly dropped");
+        }
         Err(e) => {
             panic!("Failed to receive transaction status: {:?}", e);
         }

crates/core/src/tests/integration.rs

@@ -537,6 +537,7 @@ pub enum TransactionStatusEvent {
     SimulationFailure((TransactionError, TransactionMetadata)),
     ExecutionFailure((TransactionError, TransactionMetadata)),
     VerificationFailure(String),
+    Dropped,
 }
 
 #[derive(Debug)]
@@ -615,6 +616,14 @@ pub struct SimnetConfig {
     /// Snapshot accounts to preload at startup.
     /// Keys are pubkey strings, values can be None to fetch from remote RPC.
     pub snapshot: BTreeMap<String, Option<AccountSnapshot>>,
+    /// Probability (0.0–1.0) that any given transaction will be randomly dropped,
+    /// simulating real-world packet loss or leader rejection.
+    #[serde(default)]
+    pub transaction_drop_rate: Option<f64>,
+    /// Maximum random delay in milliseconds applied before executing each transaction,
+    /// simulating out-of-order execution under high throughput.
+    #[serde(default)]
+    pub transaction_execution_delay_ms: Option<u64>,
 }
 
 impl Default for SimnetConfig {
@@ -633,6 +642,8 @@ impl Default for SimnetConfig {
             skip_signature_verification: false,
             surfnet_id: "default".to_string(),
             snapshot: BTreeMap::new(),
+            transaction_drop_rate: None,
+            transaction_execution_delay_ms: None,
         }
     }
 }