slotstrike 1.0.0

Low-latency Solana slotstrike runtime for event-driven token execution
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

use std::{
    sync::Arc,
    time::{SystemTime, UNIX_EPOCH},
};

use solana_sdk::transaction::VersionedTransaction;

const HARDWARE_TIMESTAMP_MAX_SKEW_NS: u64 = 5_000_000_000;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum IngressSource {
    Websocket,
    Grpc,
    PrivateShred,
}

impl IngressSource {
    #[inline(always)]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Websocket => "sof_websocket",
            Self::Grpc => "sof_grpc",
            Self::PrivateShred => "sof_private_shred",
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub struct IngressMetadata {
    pub source: IngressSource,
    pub hardware_timestamp_ns: Option<u64>,
    pub received_timestamp_ns: u64,
    pub normalized_timestamp_ns: u64,
}

impl IngressMetadata {
    #[inline(always)]
    pub const fn from_hardware_clock(
        source: IngressSource,
        hardware_timestamp_ns: Option<u64>,
        received_timestamp_ns: u64,
    ) -> Self {
        Self {
            source,
            hardware_timestamp_ns,
            received_timestamp_ns,
            normalized_timestamp_ns: normalize_hardware_timestamp_ns(
                hardware_timestamp_ns,
                received_timestamp_ns,
            ),
        }
    }

    #[inline(always)]
    pub const fn from_receive_clock(source: IngressSource, received_timestamp_ns: u64) -> Self {
        Self::from_hardware_clock(source, None, received_timestamp_ns)
    }
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum RaydiumCandidateKind {
    Cpmm,
    OpenBook,
}

impl RaydiumCandidateKind {
    #[inline(always)]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Cpmm => "cpmm",
            Self::OpenBook => "openbook",
        }
    }
}

#[derive(Clone, Debug)]
pub struct RaydiumCandidateEvent {
    pub kind: RaydiumCandidateKind,
    pub transaction: Arc<VersionedTransaction>,
    pub ingress: IngressMetadata,
}

#[derive(Clone, Debug)]
pub enum SniperInputEvent {
    RaydiumCandidate(RaydiumCandidateEvent),
}

#[inline(always)]
pub const fn normalize_hardware_timestamp_ns(
    hardware_timestamp_ns: Option<u64>,
    received_timestamp_ns: u64,
) -> u64 {
    match hardware_timestamp_ns {
        Some(value) if value != 0 => {
            let min = received_timestamp_ns.saturating_sub(HARDWARE_TIMESTAMP_MAX_SKEW_NS);
            let max = received_timestamp_ns.saturating_add(HARDWARE_TIMESTAMP_MAX_SKEW_NS);
            if value < min || value > max {
                received_timestamp_ns
            } else {
                value
            }
        }
        _ => received_timestamp_ns,
    }
}

#[inline(always)]
pub fn unix_timestamp_now_ns() -> u64 {
    let Ok(duration) = SystemTime::now().duration_since(UNIX_EPOCH) else {
        return 0;
    };

    u64::try_from(duration.as_nanos()).unwrap_or(u64::MAX)
}

#[cfg(test)]
mod tests {
    use super::{
        IngressMetadata, IngressSource, normalize_hardware_timestamp_ns, unix_timestamp_now_ns,
    };

    #[test]
    fn accepts_hardware_timestamp_within_skew_window() {
        let receive_ns = 10_000_000_000_u64;
        let hardware_ns = receive_ns.saturating_sub(250_000);

        assert_eq!(
            normalize_hardware_timestamp_ns(Some(hardware_ns), receive_ns),
            hardware_ns
        );
    }

    #[test]
    fn clamps_outlier_hardware_timestamp_to_receive_clock() {
        let receive_ns = 10_000_000_000_u64;
        let outlier_ns = receive_ns.saturating_add(10_000_000_000);

        assert_eq!(
            normalize_hardware_timestamp_ns(Some(outlier_ns), receive_ns),
            receive_ns
        );
    }

    #[test]
    fn builds_receive_clock_metadata() {
        let receive_ns = unix_timestamp_now_ns();
        let metadata = IngressMetadata::from_receive_clock(IngressSource::Websocket, receive_ns);

        assert_eq!(metadata.source, IngressSource::Websocket);
        assert_eq!(metadata.hardware_timestamp_ns, None);
        assert_eq!(metadata.normalized_timestamp_ns, receive_ns);
    }
}