clmm-common 0.1.39

Blockchain, Clmm for Solana
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

use crate::command::CliConfig;
use crate::contract::instructions::tick::get_tick_info;
use crate::contract::state::position::Position;
use crate::contract::state::tick::Tick;
use crate::contract::state::{Clmmpool, TickArray};
use crate::program::{MINT_WRAPPER_PROGRAM_ID, SWAP_PROGRAM_ID};
use crate::utils::sighash;
use borsh::{BorshDeserialize, BorshSerialize};
use solana_client::rpc_client::RpcClient;
use solana_program::instruction::{AccountMeta, Instruction};
use solana_program::pubkey::Pubkey;
use spl_associated_token_account::get_associated_token_address;
use spl_associated_token_account::instruction::create_associated_token_account;

#[derive(BorshSerialize, BorshDeserialize, PartialEq, Eq, Debug, Clone)]
pub struct CollectRewarderArgs {
    pub rewarder_index: u8,
}

#[allow(clippy::too_many_arguments)]
pub fn new_collect_rewarder(
    clmmpool: Pubkey,
    position: Pubkey,
    position_ata: Pubkey,
    rewarder_ata: Pubkey,
    mint_wrapper: Pubkey,
    minter: Pubkey,
    rewarder_token_mint: Pubkey,
    tick_array_lower: Pubkey,
    tick_array_upper: Pubkey,
    rewarder_index: u8,
    payer: Pubkey,
) -> Instruction {
    let data = &CollectRewarderArgs { rewarder_index };

    let mut dsa = data.try_to_vec().unwrap();
    let mut distor = sighash::sighash("global", "collect_rewarder").to_vec();
    distor.append(&mut dsa);

    Instruction {
        program_id: SWAP_PROGRAM_ID,
        accounts: vec![
            AccountMeta::new_readonly(payer, true),
            AccountMeta::new(clmmpool, false),
            AccountMeta::new(position, false),
            AccountMeta::new_readonly(position_ata, false),
            AccountMeta::new(rewarder_ata, false),
            AccountMeta::new(mint_wrapper, false),
            AccountMeta::new(minter, false),
            AccountMeta::new_readonly(MINT_WRAPPER_PROGRAM_ID, false),
            AccountMeta::new(rewarder_token_mint, false),
            AccountMeta::new_readonly(tick_array_lower, false),
            AccountMeta::new_readonly(tick_array_upper, false),
            AccountMeta::new_readonly(spl_token::id(), false),
        ],
        data: distor,
    }
}

pub fn new_collect_rewarder_tx(
    rpc_client: &RpcClient,
    config: &CliConfig,
    mint: Pubkey,
    rewarder_index: u8,
) -> Vec<Instruction> {
    let (position, _) =
        Pubkey::find_program_address(&[b"position", mint.as_ref()], &SWAP_PROGRAM_ID);
    let mut position_info = Position::get_info(rpc_client, &position);

    let mut clmmpool_info = Clmmpool::get_info(rpc_client, &position_info.clmmpool);

    let position_ata =
        get_associated_token_address(&config.pubkey().unwrap(), &position_info.position_nft_mint);

    let reward = clmmpool_info.reward_infos.0.as_slice()[rewarder_index as usize];

    let rewarder_ata = get_associated_token_address(&config.pubkey().unwrap(), &reward.mint);

    let mut ixs = vec![];

    if rpc_client.get_account(&rewarder_ata).is_err() {
        ixs.push(create_associated_token_account(
            &config.pubkey().unwrap(),
            &config.pubkey().unwrap(),
            &reward.mint,
            &spl_token::id(),
        ));
    }

    let array_lower_index =
        TickArray::array_index(position_info.tick_lower_index, clmmpool_info.tick_spacing).unwrap();
    let (tick_array_lower_pubkey, _) = TickArray::calculate_tick_array_key(
        position_info.clmmpool.as_ref(),
        array_lower_index.to_le_bytes().as_ref(),
    );

    let array_upper_index =
        TickArray::array_index(position_info.tick_upper_index, clmmpool_info.tick_spacing).unwrap();
    let (tick_array_upper_pubkey, _) = TickArray::calculate_tick_array_key(
        position_info.clmmpool.as_ref(),
        array_upper_index.to_le_bytes().as_ref(),
    );

    let tick_lower = get_tick_info(
        rpc_client,
        position_info.tick_lower_index,
        &position_info.clmmpool,
    );
    let tick_upper = get_tick_info(
        rpc_client,
        position_info.tick_upper_index,
        &position_info.clmmpool,
    );

    let rewards = Tick::get_reward_in_tick_range(
        &mut clmmpool_info,
        Some(&tick_lower),
        Some(&tick_upper),
        position_info.tick_lower_index,
        position_info.tick_upper_index,
    );
    position_info.update_rewarder(&rewards);
    if position_info.reward_infos.0.as_slice()[rewarder_index as usize].amount_owed == 0 {
        return vec![];
    }
    ixs.push(new_collect_rewarder(
        position_info.clmmpool,
        position,
        position_ata,
        rewarder_ata,
        reward.mint_wrapper,
        reward.minter,
        reward.mint,
        tick_array_lower_pubkey,
        tick_array_upper_pubkey,
        rewarder_index,
        config.pubkey().unwrap(),
    ));

    ixs
}