Nicolas/introduced new parameters

nym-vpn-core/crates/nym-vpn-lib-types/src/lib.rs

@@ -78,7 +78,7 @@ pub use rpc_requests::{
     AccountBalanceResponse, AccountCommandResponse, Coin, DecentralisedObtainTicketbooksRequest,
     ListGatewaysOptions, StoreAccountRequest,
 };
-pub use service::{TargetState, VpnServiceConfig, VpnServiceInfo};
+pub use service::{MixnetTrafficConfig, TargetState, VpnServiceConfig, VpnServiceInfo};
 pub use socks5::{HttpRpcSettings, Socks5Settings, Socks5State, Socks5Status};
 pub use tunnel_event::{
     BandwidthEvent, ConnectionEvent, ConnectionStatisticsEvent, MixnetEvent, SphinxPacketRates,

nym-vpn-core/crates/nym-vpn-lib-types/src/service.rs

@@ -10,6 +10,32 @@ use time::OffsetDateTime;
 use ts_rs::TS;
 
 use crate::{EntryPoint, ExitPoint, NetworkStatisticsConfig, NymNetworkDetails, NymVpnNetwork};
+#[cfg_attr(feature = "uniffi-bindings", derive(uniffi::Record))]
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
+pub struct MixnetTrafficConfig {
+    pub poisson_parameter: Option<u32>,
+    pub average_packet_delay: Option<u32>,
+    pub message_sending_average_delay: Option<u32>,
+
+    pub disable_poisson_rate: bool,
+    pub disable_background_cover_traffic: bool,
+
+    pub min_mixnode_performance: Option<u8>,
+    pub min_gateway_mixnet_performance: Option<u8>,
+}
+impl Default for MixnetTrafficConfig {
+    fn default() -> Self {
+        Self {
+            poisson_parameter: None,
+            average_packet_delay: None,
+            message_sending_average_delay: None,
+            disable_poisson_rate: false,
+            disable_background_cover_traffic: false,
+            min_mixnode_performance: None,
+            min_gateway_mixnet_performance: None,
+        }
+    }
+}
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 #[cfg_attr(feature = "uniffi-bindings", derive(uniffi::Record))]
@@ -21,6 +47,7 @@ use crate::{EntryPoint, ExitPoint, NetworkStatisticsConfig, NymNetworkDetails, N
 )]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "typescript-bindings", serde(rename_all = "camelCase"))]
+
 pub struct VpnServiceConfig {
     pub entry_point: EntryPoint,
     pub exit_point: ExitPoint,
@@ -29,15 +56,12 @@ pub struct VpnServiceConfig {
     pub enable_two_hop: bool,
     pub enable_bridges: bool,
     pub netstack: bool,
-    pub disable_poisson_rate: bool,
-    pub disable_background_cover_traffic: bool,
-    pub min_mixnode_performance: Option<u8>,
-    pub min_gateway_mixnet_performance: Option<u8>,
     pub min_gateway_vpn_performance: Option<u8>,
     pub residential_exit: bool,
     pub enable_custom_dns: bool,
     pub custom_dns: Vec<IpAddr>,
     pub network_stats: NetworkStatisticsConfig,
+    pub mixnet_traffic: MixnetTrafficConfig,
 }
 
 impl fmt::Display for VpnServiceConfig {
@@ -55,15 +79,18 @@ impl fmt::Display for VpnServiceConfig {
         writeln!(
             f,
             "disable_poisson_rate: {}, disable_background_cover_traffic: {}",
-            self.disable_poisson_rate, self.disable_background_cover_traffic
+            self.mixnet_traffic.disable_poisson_rate,
+            self.mixnet_traffic.disable_background_cover_traffic
         )?;
         writeln!(
             f,
             "min_mixnode_performance: {}, min_gateway_mixnet_performance: {}, min_gateway_vpn_performance: {}",
-            self.min_mixnode_performance
+            self.mixnet_traffic
+                .min_mixnode_performance
                 .map(|p| p.to_string())
                 .unwrap_or_else(|| "<None>".to_string()),
-            self.min_gateway_mixnet_performance
+            self.mixnet_traffic
+                .min_gateway_mixnet_performance
                 .map(|p| p.to_string())
                 .unwrap_or_else(|| "<None>".to_string()),
             self.min_gateway_vpn_performance
@@ -82,10 +109,27 @@ impl fmt::Display for VpnServiceConfig {
                 .join(", ")
         )?;
         writeln!(f, "networks stats config: {}", self.network_stats)?;
+        writeln!(
+            f,
+            "poisson_parameter: {:?}",
+            self.mixnet_traffic.poisson_parameter
+        )?;
+        writeln!(
+            f,
+            "average_packet_delay: {} ms, message_sending_average_delay: {} ms",
+            self.mixnet_traffic
+                .average_packet_delay
+                .map(|v| format!("{v}"))
+                .unwrap_or_else(|| "<Default>".to_string()),
+            self.mixnet_traffic
+                .message_sending_average_delay
+                .map(|v| format!("{v}"))
+                .unwrap_or_else(|| "<Default>".to_string())
+        )?;
+
         Ok(())
     }
 }
-
 impl Default for VpnServiceConfig {
     fn default() -> Self {
         Self {
@@ -96,15 +140,12 @@ impl Default for VpnServiceConfig {
             enable_two_hop: true,
             enable_bridges: false,
             netstack: false,
-            disable_poisson_rate: false,
-            disable_background_cover_traffic: false,
-            min_mixnode_performance: None,
-            min_gateway_mixnet_performance: None,
             min_gateway_vpn_performance: None,
             residential_exit: false,
             enable_custom_dns: false,
             custom_dns: vec![],
             network_stats: Default::default(),
+            mixnet_traffic: MixnetTrafficConfig::default(),
         }
     }
 }

nym-vpn-core/crates/nym-vpn-lib/src/tunnel_state_machine/mod.rs

@@ -737,7 +737,6 @@ impl TunnelStateMachine {
                     &mut self.shared_state,
                 )
                 .await;
-
             match next_state {
                 NextTunnelState::NewState((new_state_handler, new_state)) => {
                     self.current_state_handler = new_state_handler;

nym-vpn-core/crates/nym-vpn-proto/proto/nym_vpn_service.proto

@@ -245,6 +245,18 @@ message Threshold {
   uint32 min_performance = 1;
 }
 
+message MixnetTrafficConfig {
+  optional uint32 poisson_parameter = 1;
+  optional uint32 average_packet_delay = 2;
+  optional uint32 message_sending_average_delay = 3;
+
+  bool disable_poisson_rate = 4;
+  bool disable_background_cover_traffic = 5;
+
+  optional uint32 min_mixnode_performance = 6;
+  optional uint32 min_gateway_mixnet_performance = 7;
+}
+
 message VpnServiceConfig {
   EntryNode entry_point = 1;
   ExitNode exit_point = 2;
@@ -254,14 +266,14 @@ message VpnServiceConfig {
   bool enable_bridges = 21;
   bool residential_exit = 15;
   bool netstack = 13;
-  bool disable_poisson_rate = 6;
-  bool disable_background_cover_traffic = 7;
-  optional uint32 min_mixnode_performance = 8;
-  optional uint32 min_gateway_mixnet_performance = 9;
-  optional uint32 min_gateway_vpn_performance = 10;
+
   bool enable_custom_dns = 17;
   IpAddrList custom_dns = 16;
+  optional uint32 min_gateway_vpn_performance = 10;
+
   NetworkStatsConfig network_stats = 18;
+
+  MixnetTrafficConfig mixnet_traffic = 25;
 }
 
 message NetworkStatsConfig {
@@ -843,10 +855,22 @@ message NetworkStatisticsIdentity {
     string id = 2;
 }
 
+message SetMessageSendingAverageDelayRequest {
+    uint32 delay_ms = 1;
+}
+message SetDisablePoissonRateRequest {
+  bool disable = 1;
+}
+message SetPoissonParameterRequest {
+  uint32 poisson_parameter = 1;
+}
+message SetAveragePacketDelayRequest {
+    uint32 delay_ms = 1;
+}
+
 service NymVpnService {
   // Get info regarding the nym-vpnd in general, like version etc.
   rpc Info (google.protobuf.Empty) returns (InfoResponse) {}
-
   // Get the VPN service configuration
   rpc GetConfig (google.protobuf.Empty) returns (GetConfigResponse) {}
 
@@ -861,6 +885,10 @@ service NymVpnService {
   rpc SetResidentialExit (google.protobuf.BoolValue) returns (google.protobuf.Empty) {}
   rpc SetEnableCustomDns (google.protobuf.BoolValue) returns (google.protobuf.Empty) {}
   rpc SetCustomDns (IpAddrList) returns (google.protobuf.Empty) {}
+  rpc SetPoissonParameter (SetPoissonParameterRequest) returns (google.protobuf.Empty);
+  rpc SetDisablePoissonRate (SetDisablePoissonRateRequest) returns (google.protobuf.Empty);
+  rpc SetAveragePacketDelay(SetAveragePacketDelayRequest) returns (google.protobuf.Empty);
+  rpc SetMessageSendingAverageDelay(SetMessageSendingAverageDelayRequest) returns (google.protobuf.Empty);
 
   // Set the network. This requires a restart to take effect
   rpc SetNetwork (google.protobuf.StringValue) returns (google.protobuf.Empty) {}

nym-vpn-core/crates/nym-vpn-proto/src/conversions/service.rs

@@ -32,6 +32,20 @@ impl TryFrom<proto::VpnServiceConfig> for nym_vpn_lib_types::VpnServiceConfig {
             ))?
             .into();
 
+        let mt = value.mixnet_traffic.ok_or(ConversionError::NoValueSet(
+            "VpnServiceConfig.mixnet_traffic",
+        ))?;
+
+        let mixnet_traffic = nym_vpn_lib_types::MixnetTrafficConfig {
+            poisson_parameter: mt.poisson_parameter,
+            average_packet_delay: mt.average_packet_delay,
+            message_sending_average_delay: mt.message_sending_average_delay,
+            disable_poisson_rate: mt.disable_poisson_rate,
+            disable_background_cover_traffic: mt.disable_background_cover_traffic,
+            min_mixnode_performance: mt.min_mixnode_performance.map(|u| u as u8),
+            min_gateway_mixnet_performance: mt.min_gateway_mixnet_performance.map(|u| u as u8),
+        };
+
         let config = nym_vpn_lib_types::VpnServiceConfig {
             entry_point,
             exit_point,
@@ -40,15 +54,14 @@ impl TryFrom<proto::VpnServiceConfig> for nym_vpn_lib_types::VpnServiceConfig {
             enable_two_hop: value.enable_two_hop,
             enable_bridges: value.enable_bridges,
             netstack: value.netstack,
-            disable_poisson_rate: value.disable_poisson_rate,
-            disable_background_cover_traffic: value.disable_background_cover_traffic,
-            min_mixnode_performance: value.min_mixnode_performance.map(|u| u as u8),
-            min_gateway_mixnet_performance: value.min_gateway_mixnet_performance.map(|u| u as u8),
-            min_gateway_vpn_performance: value.min_gateway_vpn_performance.map(|u| u as u8),
+
             residential_exit: value.residential_exit,
             enable_custom_dns: value.enable_custom_dns,
             custom_dns,
             network_stats,
+
+            min_gateway_vpn_performance: value.min_gateway_vpn_performance.map(|u| u as u8),
+            mixnet_traffic,
         };
         Ok(config)
     }
@@ -59,7 +72,21 @@ impl From<nym_vpn_lib_types::VpnServiceConfig> for proto::VpnServiceConfig {
         let entry_point = Some(proto::EntryNode::from(value.entry_point));
         let exit_point = Some(proto::ExitNode::from(value.exit_point));
         let custom_dns = Some(proto::IpAddrList::from(value.custom_dns));
-
+        let mixnet_traffic = Some(proto::MixnetTrafficConfig {
+            poisson_parameter: value.mixnet_traffic.poisson_parameter,
+            average_packet_delay: value.mixnet_traffic.average_packet_delay,
+            message_sending_average_delay: value.mixnet_traffic.message_sending_average_delay,
+            disable_poisson_rate: value.mixnet_traffic.disable_poisson_rate,
+            disable_background_cover_traffic: value.mixnet_traffic.disable_background_cover_traffic,
+            min_mixnode_performance: value
+                .mixnet_traffic
+                .min_mixnode_performance
+                .map(|u| u as u32),
+            min_gateway_mixnet_performance: value
+                .mixnet_traffic
+                .min_gateway_mixnet_performance
+                .map(|u| u as u32),
+        });
         proto::VpnServiceConfig {
             entry_point,
             exit_point,
@@ -68,15 +95,15 @@ impl From<nym_vpn_lib_types::VpnServiceConfig> for proto::VpnServiceConfig {
             enable_two_hop: value.enable_two_hop,
             enable_bridges: value.enable_bridges,
             netstack: value.netstack,
-            disable_poisson_rate: value.disable_poisson_rate,
-            disable_background_cover_traffic: value.disable_background_cover_traffic,
-            min_mixnode_performance: value.min_mixnode_performance.map(|u| u as u32),
-            min_gateway_mixnet_performance: value.min_gateway_mixnet_performance.map(|u| u as u32),
-            min_gateway_vpn_performance: value.min_gateway_vpn_performance.map(|u| u as u32),
             residential_exit: value.residential_exit,
             enable_custom_dns: value.enable_custom_dns,
             custom_dns,
+
             network_stats: Some(proto::NetworkStatsConfig::from(value.network_stats)),
+
+            min_gateway_vpn_performance: value.min_gateway_vpn_performance.map(|u| u as u32),
+
+            mixnet_traffic,
         }
     }
 }

nym-vpn-core/crates/nym-vpn-proto/src/rpc_client.rs

@@ -77,7 +77,51 @@ impl RpcClient {
 
         Ok(())
     }
+    pub async fn set_poisson_parameter(&mut self, value: u32) -> Result<()> {
+        let request = proto::SetPoissonParameterRequest {
+            poisson_parameter: value,
+        };
+
+        self.0
+            .set_poisson_parameter(request)
+            .await
+            .map_err(Error::Rpc)?;
+        Ok(())
+    }
+    /// Sets the average per-mixnode packet delay (in milliseconds)
+    pub async fn set_average_packet_delay(&mut self, delay_ms: u32) -> Result<()> {
+        let request = proto::SetAveragePacketDelayRequest { delay_ms };
+
+        self.0
+            .set_average_packet_delay(request)
+            .await
+            .map_err(Error::Rpc)?
+            .into_inner();
+
+        Ok(())
+    }
 
+    /// Sets the average real traffic message-sending delay (in milliseconds)
+    pub async fn set_message_sending_average_delay(&mut self, delay_ms: u32) -> Result<()> {
+        let request = proto::SetMessageSendingAverageDelayRequest { delay_ms };
+
+        self.0
+            .set_message_sending_average_delay(request)
+            .await
+            .map_err(Error::Rpc)?
+            .into_inner();
+
+        Ok(())
+    }
+    pub async fn set_disable_poisson_rate(&mut self, disable: bool) -> Result<()> {
+        let request = proto::SetDisablePoissonRateRequest { disable };
+        self.0
+            .set_disable_poisson_rate(request)
+            .await
+            .map_err(Error::Rpc)?
+            .into_inner();
+        Ok(())
+    }
     pub async fn set_disable_ipv6(&mut self, disable_ipv6: bool) -> Result<()> {
         self.0
             .set_disable_ipv6(disable_ipv6)