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

use crate::domain::{aggregates::RuleBook, entities::SnipeRule};

#[derive(Clone, Copy, Debug)]
pub struct MintAddressMatchSpecification<'address> {
    token_address: &'address str,
}

impl<'address> MintAddressMatchSpecification<'address> {
    #[inline(always)]
    pub const fn new(token_address: &'address str) -> Self {
        Self { token_address }
    }

    #[inline(always)]
    pub fn select(self, rule_book: &RuleBook) -> Option<&SnipeRule> {
        rule_book.mint_rule(self.token_address)
    }
}

#[derive(Clone, Copy, Debug)]
pub struct DeployerAddressMatchSpecification<'address> {
    deployer_address: &'address str,
}

impl<'address> DeployerAddressMatchSpecification<'address> {
    #[inline(always)]
    pub const fn new(deployer_address: &'address str) -> Self {
        Self { deployer_address }
    }

    #[inline(always)]
    pub fn select(self, rule_book: &RuleBook) -> Option<&SnipeRule> {
        rule_book.deployer_rule(self.deployer_address)
    }
}

#[cfg(test)]
mod tests {
    use super::{DeployerAddressMatchSpecification, MintAddressMatchSpecification};
    use crate::domain::{
        aggregates::RuleBook,
        entities::SnipeRule,
        value_objects::{RuleAddress, RuleSlippageBps, RuleSolAmount, sol_amount::Lamports},
    };

    fn build_rule(address: &str) -> Option<SnipeRule> {
        let address = RuleAddress::try_from(address).ok()?;
        let slippage = RuleSlippageBps::from_pct_str("1").ok()?;
        Some(SnipeRule::new(
            address,
            RuleSolAmount::new(Lamports::new(1_000_000_000)),
            RuleSolAmount::new(Lamports::new(100_000_000)),
            slippage,
        ))
    }

    #[test]
    fn selects_mint_rule_by_address() {
        let mint_rule = build_rule("So11111111111111111111111111111111111111112");
        assert!(mint_rule.is_some());

        if let Some(mint_rule) = mint_rule {
            let book = RuleBook::new(vec![mint_rule], Vec::new());
            let selected =
                MintAddressMatchSpecification::new("So11111111111111111111111111111111111111112")
                    .select(&book);
            assert!(selected.is_some());
        }
    }

    #[test]
    fn selects_deployer_rule_by_address() {
        let deployer_rule = build_rule("11111111111111111111111111111111");
        assert!(deployer_rule.is_some());

        if let Some(deployer_rule) = deployer_rule {
            let book = RuleBook::new(Vec::new(), vec![deployer_rule]);
            let selected =
                DeployerAddressMatchSpecification::new("11111111111111111111111111111111")
                    .select(&book);
            assert!(selected.is_some());
        }
    }
}