phantom-protocol 0.1.0

Phantom Universal Transport Core SDK — post-quantum secure L4/L6 network framework
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use std::time::Duration;

#[cfg_attr(feature = "bindings", derive(uniffi::Record))]
#[derive(Debug, Clone)]
// New tunables must not break downstream construction. Build via `mobile()` /
// `server()` / `iot()` / `default()` then mutate the public fields.
#[non_exhaustive]
pub struct PhantomConfig {
    /// Interval between keep-alive pings
    pub keepalive_interval: Duration,
    /// Session inactivity timeout
    pub session_timeout: Duration,
    /// Maximum packet size (MTU)
    pub max_packet_size: u32,
    /// Send buffer size in packets
    pub send_buffer_size: u32,
    /// Receive buffer size in packets
    pub recv_buffer_size: u32,
    /// Maximum tickets in session cache
    pub session_cache_capacity: u32,
    /// Lifetime of a session ticket
    pub session_ticket_lifetime: Duration,
    /// Enable automatic transport fallback
    pub auto_fallback: bool,
    /// Packet loss percentage to trigger fallback
    pub fallback_loss_threshold: u8,
    /// Connection failures to trigger fallback
    pub fallback_failure_threshold: u32,
    /// Timeout for connection attempts
    pub connect_timeout: Duration,
    /// Delay before attempting to upgrade transport
    pub upgrade_delay: Duration,
}

impl Default for PhantomConfig {
    fn default() -> Self {
        Self::mobile()
    }
}

impl PhantomConfig {
    /// Optimized for mobile devices (LTE/Wi-Fi transitions, power saving)
    pub fn mobile() -> Self {
        Self {
            keepalive_interval: Duration::from_secs(30),
            session_timeout: Duration::from_secs(3600),
            max_packet_size: 1350,
            send_buffer_size: 256,
            recv_buffer_size: 1024,
            session_cache_capacity: 32,
            session_ticket_lifetime: Duration::from_secs(86400),
            auto_fallback: true,
            fallback_loss_threshold: 15,
            fallback_failure_threshold: 3,
            connect_timeout: Duration::from_secs(5),
            upgrade_delay: Duration::from_secs(60),
        }
    }

    /// Optimized for servers (high throughput, static IP)
    pub fn server() -> Self {
        Self {
            keepalive_interval: Duration::from_secs(60),
            session_timeout: Duration::from_secs(7200),
            max_packet_size: 1440,
            send_buffer_size: 2048,
            recv_buffer_size: 8192,
            session_cache_capacity: 1024,
            session_ticket_lifetime: Duration::from_secs(604800),
            auto_fallback: false,
            fallback_loss_threshold: 20,
            fallback_failure_threshold: 5,
            connect_timeout: Duration::from_secs(2),
            upgrade_delay: Duration::from_secs(300),
        }
    }

    /// Optimized for IoT devices (extremely low memory, slow networks)
    pub fn iot() -> Self {
        Self {
            keepalive_interval: Duration::from_secs(120),
            session_timeout: Duration::from_secs(1800),
            max_packet_size: 512,
            send_buffer_size: 32,
            recv_buffer_size: 64,
            session_cache_capacity: 4,
            session_ticket_lifetime: Duration::from_secs(3600),
            auto_fallback: true,
            fallback_loss_threshold: 25,
            fallback_failure_threshold: 2,
            connect_timeout: Duration::from_secs(10),
            upgrade_delay: Duration::from_secs(600),
        }
    }
}