lb_clmm_fork 0.5.2

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

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

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

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, sender: Pubkey) -> bool;
}

struct PermissionLbPairActionAccess {
    is_enabled: bool,
    activated: bool,
    pre_swap_activated: bool,
    whitelisted_wallet: Pubkey,
    pre_activation_swap_address: Pubkey,
}

impl PermissionLbPairActionAccess {
    pub fn new(lb_pair: &LbPair, current_slot: u64, pre_activation_swap_start_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,
            pre_activation_swap_address: lb_pair.pre_activation_swap_address,
            pre_swap_activated: current_slot >= pre_activation_swap_start_slot,
        }
    }
}

impl LbPairTypeActionAccess for PermissionLbPairActionAccess {
    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;
        }

        self.activated
            || !self.whitelisted_wallet.eq(&Pubkey::default())
                && self.whitelisted_wallet.eq(&wallet)
    }

    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, sender: Pubkey) -> bool {
        let activated = if self.pre_activation_swap_address.eq(&sender) {
            self.pre_swap_activated
        } else {
            self.activated
        };

        self.is_enabled && activated
    }
}

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, _sender: Pubkey) -> bool {
        self.is_enabled
    }
}

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 pre_activation_start_slot = lb_pair.get_pre_activation_start_slot();
        let permission_pair_access_validator =
            PermissionLbPairActionAccess::new(lb_pair, current_slot, pre_activation_start_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))
    }
}