lb_clmm 0.1.1

Created with Anchor
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

use super::lb_pair::{LbPair, PairStatus};

use anchor_lang::prelude::*;
use solana_program::pubkey::Pubkey;

pub trait LbPairTypeActionAccess {
    fn validate_add_liquidity_access(&self, wallet: Pubkey) -> bool;
    fn validate_initialize_bin_array_access(&self, wallet: Pubkey) -> bool;
    fn validate_initialize_position_access(&self, wallet: Pubkey) -> bool;
    fn validate_swap_access(&self) -> bool;
    fn get_swap_cap_status_and_amount(&self, swap_for_y: bool) -> (bool, u64);
}

struct PermissionLbPairActionAccess<'a> {
    is_enabled: bool,
    activated: bool,
    throttled: bool,
    max_swapped_amount: u64,
    whitelisted_wallet: &'a [Pubkey],
}

impl<'a> PermissionLbPairActionAccess<'a> {
    pub fn new(lb_pair: &'a LbPair, current_slot: u64) -> Self {
        Self {
            whitelisted_wallet: &lb_pair.whitelisted_wallet,
            is_enabled: lb_pair.status == Into::<u8>::into(PairStatus::Enabled),
            activated: current_slot >= lb_pair.activation_slot,
            throttled: current_slot <= lb_pair.swap_cap_deactivate_slot,
            max_swapped_amount: lb_pair.max_swapped_amount,
        }
    }
}

impl<'a> LbPairTypeActionAccess for PermissionLbPairActionAccess<'a> {
    fn validate_add_liquidity_access(&self, wallet: Pubkey) -> bool {
        // Pair disabled due to emergency mode. Nothing can be deposited.
        if !self.is_enabled {
            return false;
        }

        let is_wallet_whitelisted = is_wallet_in_whitelist(&wallet, &self.whitelisted_wallet);
        self.activated || is_wallet_whitelisted
    }

    fn validate_initialize_bin_array_access(&self, wallet: Pubkey) -> bool {
        self.validate_add_liquidity_access(wallet)
    }

    fn validate_initialize_position_access(&self, wallet: Pubkey) -> bool {
        self.validate_add_liquidity_access(wallet)
    }

    fn validate_swap_access(&self) -> bool {
        self.is_enabled && self.activated
    }

    fn get_swap_cap_status_and_amount(&self, swap_for_y: bool) -> (bool, u64) {
        // no cap when user sell
        if swap_for_y {
            return (false, u64::MAX);
        }
        return (
            self.throttled && self.max_swapped_amount < u64::MAX,
            self.max_swapped_amount,
        );
    }
}

struct PermissionlessLbPairActionAccess {
    is_enabled: bool,
}

impl PermissionlessLbPairActionAccess {
    pub fn new(lb_pair: &LbPair) -> Self {
        Self {
            is_enabled: lb_pair.status == Into::<u8>::into(PairStatus::Enabled),
        }
    }
}

impl LbPairTypeActionAccess for PermissionlessLbPairActionAccess {
    fn validate_add_liquidity_access(&self, _wallet: Pubkey) -> bool {
        self.is_enabled
    }

    fn validate_initialize_bin_array_access(&self, _wallet: Pubkey) -> bool {
        self.is_enabled
    }

    fn validate_initialize_position_access(&self, _wallet: Pubkey) -> bool {
        self.is_enabled
    }

    fn validate_swap_access(&self) -> bool {
        self.is_enabled
    }
    fn get_swap_cap_status_and_amount(&self, swap_for_y: bool) -> (bool, u64) {
        (false, u64::MAX)
    }
}

pub fn get_lb_pair_type_access_validator<'a>(
    lb_pair: &'a LbPair,
    current_slot: u64,
) -> Result<Box<dyn LbPairTypeActionAccess + 'a>> {
    if lb_pair.is_permission_pair()? {
        let permission_pair_access_validator =
            PermissionLbPairActionAccess::new(&lb_pair, current_slot);

        Ok(Box::new(permission_pair_access_validator))
    } else {
        let permissionless_pair_access_validator = PermissionlessLbPairActionAccess::new(&lb_pair);
        Ok(Box::new(permissionless_pair_access_validator))
    }
}

pub fn is_wallet_in_whitelist(wallet: &Pubkey, whitelist: &[Pubkey]) -> bool {
    !wallet.eq(&Pubkey::default()) && whitelist.iter().find(|&&w| w.eq(&wallet)).is_some()
}