sol-parser-sdk 0.7.2

A lightweight Rust library for real-time event streaming from Solana DEX trading programs. Supports PumpFun, PumpSwap, Raydium LaunchLab, and Raydium protocols with Yellowstone gRPC and ShredStream.
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

use std::collections::HashMap;

use smallvec::SmallVec;
use solana_sdk::pubkey::Pubkey;

pub(crate) type InvokePosition = (i32, i32);

pub(crate) trait InvokeLookup {
    fn get_invokes(&self, program_id: &Pubkey) -> Option<&[InvokePosition]>;
}

impl InvokeLookup for HashMap<Pubkey, Vec<InvokePosition>> {
    #[inline]
    fn get_invokes(&self, program_id: &Pubkey) -> Option<&[InvokePosition]> {
        self.get(program_id).map(Vec::as_slice)
    }
}

/// Per-transaction invoke positions. Real swaps usually touch one or two supported
/// programs, so keeping both the program table and common position lists inline
/// avoids hashing and heap allocation on the parser hot path.
#[derive(Default)]
pub(crate) struct InvokeContext {
    entries: SmallVec<[(Pubkey, SmallVec<[InvokePosition; 4]>); 2]>,
}

impl InvokeContext {
    #[inline]
    pub(crate) fn push(&mut self, program_id: Pubkey, position: InvokePosition) {
        if let Some((_, positions)) =
            self.entries.iter_mut().find(|(candidate, _)| *candidate == program_id)
        {
            positions.push(position);
            return;
        }

        let mut positions = SmallVec::new();
        positions.push(position);
        self.entries.push((program_id, positions));
    }
}

impl InvokeLookup for InvokeContext {
    #[inline]
    fn get_invokes(&self, program_id: &Pubkey) -> Option<&[InvokePosition]> {
        self.entries
            .iter()
            .find(|(candidate, _)| candidate == program_id)
            .map(|(_, positions)| positions.as_slice())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn groups_positions_by_program() {
        let first = Pubkey::new_unique();
        let second = Pubkey::new_unique();
        let mut context = InvokeContext::default();
        context.push(first, (1, -1));
        context.push(second, (2, 0));
        context.push(first, (1, 3));

        assert_eq!(context.get_invokes(&first), Some(&[(1, -1), (1, 3)][..]));
        assert_eq!(context.get_invokes(&second), Some(&[(2, 0)][..]));
        assert_eq!(context.get_invokes(&Pubkey::new_unique()), None);
    }

    #[test]
    fn spills_without_losing_programs_or_positions() {
        let programs = [Pubkey::new_unique(), Pubkey::new_unique(), Pubkey::new_unique()];
        let mut context = InvokeContext::default();
        for outer in 0..6 {
            context.push(programs[0], (outer, -1));
        }
        context.push(programs[1], (10, 1));
        context.push(programs[2], (11, 2));

        assert_eq!(context.get_invokes(&programs[0]).map(<[_]>::len), Some(6));
        assert_eq!(context.get_invokes(&programs[1]), Some(&[(10, 1)][..]));
        assert_eq!(context.get_invokes(&programs[2]), Some(&[(11, 2)][..]));
    }
}