clpcpi 0.1.4

Concentrated Liquidity Provider Vault (CLP) Vault CPI struct reference and CPI examples.
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198

use std::str::FromStr;

use crate::state::ClpVault;
use crate::{keys::CLPVAULT_PROGRAM_KEY, utils::get_function_hash};
use anchor_lang::prelude::*;
use anchor_lang::solana_program::{instruction::Instruction, program::invoke};
use crate::errors::ErrorCode;

use anchor_spl::token::{Mint, Token, TokenAccount};

/// Demo context for an IX calling CLP Vault's `deposit` IX as a CPI
#[derive(Accounts)]
pub struct DepositToClp<'info> {
    pub payer: Signer<'info>,

    #[account(mut)]
    pub user_token_a: Account<'info, TokenAccount>,

    #[account(mut)]
    pub user_token_b: Account<'info, TokenAccount>,
    /// `user_lp_token_acct`
    #[account(mut)]
    pub user_lp_token_acct: Box<Account<'info, TokenAccount>>,

    #[account(
        has_one = position_bundle_token_account @ ErrorCode::PositionBundleTokenAccountMismatch,
        has_one = token_vault_a @ ErrorCode::TokenVaultAMismatch,
        has_one = token_vault_b @ ErrorCode::TokenVaultBMismatch,
        has_one = lp_mint @ ErrorCode::LpMintMismatch,
        has_one = clp @ ErrorCode::ClpMismatch,
    )]
    pub clp_vault: AccountLoader<'info, ClpVault>,

    #[account(mut)]
    pub lp_mint: Box<Account<'info, Mint>>,
    #[account(mut)]
    pub token_vault_a: Box<Account<'info, TokenAccount>>,
    #[account(mut)]
    pub token_vault_b: Box<Account<'info, TokenAccount>>,
    /// CHECK: validated in CPI
    pub position_bundle_token_account: Box<Account<'info, TokenAccount>>,

    /// CHECK: validated in CPI
    pub clp_program: UncheckedAccount<'info>,
    /// CHECK: validated in CPI
    #[account(mut)]
    pub clp: UncheckedAccount<'info>,
    /// CHECK: validated in CPI
    #[account(mut)]
    pub clp_token_vault_a: UncheckedAccount<'info>,
    /// CHECK: validated in CPI
    #[account(mut)]
    pub clp_token_vault_b: UncheckedAccount<'info>,

    pub token_program: Program<'info, Token>,
}

pub fn handler<'info>(
    ctx: Context<'_, '_, '_, 'info, DepositToClp<'info>>,
    lp_mint_amount: u64,
    token_max_a: u64,
    token_max_b: u64,
) -> Result<()> {
    let clp_program_id: Pubkey = Pubkey::from_str(CLPVAULT_PROGRAM_KEY).unwrap();
    let instruction: Instruction = deposit_cpi_instruction(
        &ctx,
        clp_program_id,
        lp_mint_amount,
        token_max_a,
        token_max_b,
    )?;
    let mut account_infos = vec![
        ctx.accounts.payer.to_account_info(),
        ctx.accounts.token_vault_a.to_account_info(),        // a_acc.
        ctx.accounts.token_vault_b.to_account_info(),        // b_acc
        ctx.accounts.user_lp_token_acct.to_account_info(),        // lp_acc
        ctx.accounts.clp_vault.to_account_info(),     // clp_vault
        ctx.accounts.lp_mint.to_account_info(),       // lp_mint
        ctx.accounts.token_vault_a.to_account_info(), // a_vault
        ctx.accounts.token_vault_b.to_account_info(), // b_vault
        ctx.accounts.position_bundle_token_account.to_account_info(), // pos_bun
        ctx.accounts.clp_program.to_account_info(),   // clp_pro
        ctx.accounts.clp.to_account_info(),           // clp
        ctx.accounts.clp_token_vault_a.to_account_info(), // clp_a
        ctx.accounts.clp_token_vault_b.to_account_info(), // clp_b
        ctx.accounts.token_program.to_account_info(), // token
    ];
    for remaining_account_info in ctx.remaining_accounts {
        account_infos.push(remaining_account_info.clone());
    }

    invoke(
        &instruction,
        &account_infos
    )?;

    // Example with a PDA as payer:
    // invoke_signed(
    //     &instruction,
    //     &account_infos,
    //     &[clp_route_signer_seeds!(route)],
    // )?;
    Ok(())
}

pub fn deposit_cpi_instruction(
    ctx: &Context<DepositToClp>,
    program_id: Pubkey,
    lp_mint_amount: u64,
    token_max_a: u64,
    token_max_b: u64,
) -> Result<Instruction> {
    let mut accounts = vec![
        AccountMeta::new_readonly(ctx.accounts.payer.key(), true), // payer
        AccountMeta::new(ctx.accounts.token_vault_a.key(), false),        // a_acc.
        AccountMeta::new(ctx.accounts.token_vault_b.key(), false),        // b_acc
        AccountMeta::new(ctx.accounts.user_lp_token_acct.key(), false),        // lp_acc
        AccountMeta::new_readonly(ctx.accounts.clp_vault.key(), false), // clp_vault
        AccountMeta::new(ctx.accounts.lp_mint.key(), false),       // lp_mint
        AccountMeta::new(ctx.accounts.token_vault_a.key(), false), // a_vault
        AccountMeta::new(ctx.accounts.token_vault_b.key(), false), // b_vault
        AccountMeta::new_readonly(ctx.accounts.position_bundle_token_account.key(), false), // pos_bun
        AccountMeta::new_readonly(ctx.accounts.clp_program.key(), false), // clp_pro
        AccountMeta::new(ctx.accounts.clp.key(), false),                  // clp
        AccountMeta::new(ctx.accounts.clp_token_vault_a.key(), false),    // clp_a
        AccountMeta::new(ctx.accounts.clp_token_vault_b.key(), false),    // clp_b
        AccountMeta::new_readonly(ctx.accounts.token_program.key(), false), // token
    ];
    for account_info in ctx.remaining_accounts.iter() {
        accounts.push(AccountMeta::new_readonly(*account_info.key, account_info.is_signer));
    }

    let instruction = Instruction {
        program_id,
        accounts,
        data: deposit_ix_data(lp_mint_amount, token_max_a, token_max_b),
    };
    Ok(instruction)
}

#[derive(AnchorSerialize, AnchorDeserialize)]
pub struct DepositCpiArgs {
    lp_mint_amount: u64,
    token_max_a: u64,
    token_max_b: u64,
}

pub fn deposit_ix_data(lp_mint_amount: u64, token_max_a: u64, token_max_b: u64) -> Vec<u8> {
    let hash = get_function_hash("global", "deposit");
    let mut buf: Vec<u8> = vec![];
    buf.extend_from_slice(&hash);
    let args = DepositCpiArgs {
        lp_mint_amount,
        token_max_a,
        token_max_b,
    };
    args.serialize(&mut buf).unwrap();
    buf
}

/// Build a CPI instruction. 
/// 
/// See Context `DepositToClp` for the order of accounts and limitations.
pub fn deposit_cpi_ix(
    account_infos: &[AccountInfo; 14],
    remaining_account_infos: &[AccountInfo],
    program_id: Pubkey,
    lp_mint_amount: u64,
    token_max_a: u64,
    token_max_b: u64,
) -> Result<Instruction> {
    let mut accounts = vec![
        AccountMeta::new_readonly(account_infos[0].key(), true), // payer
        AccountMeta::new(account_infos[1].key(), false),         // a_acc.
        AccountMeta::new(account_infos[2].key(), false),         // b_acc
        AccountMeta::new(account_infos[3].key(), false),         // lp_acc
        AccountMeta::new_readonly(account_infos[4].key(), false), // clp_vault
        AccountMeta::new(account_infos[5].key(), false),         // lp_mint
        AccountMeta::new(account_infos[6].key(), false),         // a_vault
        AccountMeta::new(account_infos[7].key(), false),         // b_vault
        AccountMeta::new_readonly(account_infos[8].key(), false), // pos_bun
        AccountMeta::new_readonly(account_infos[9].key(), false), // clp_pro
        AccountMeta::new(account_infos[10].key(), false),        // clp
        AccountMeta::new(account_infos[11].key(), false),        // clp_a
        AccountMeta::new(account_infos[12].key(), false),        // clp_b
        AccountMeta::new_readonly(account_infos[13].key(), false), // token
    ];
    for remaining_account_info in remaining_account_infos {
        accounts.push(AccountMeta::new(remaining_account_info.key(), false));
    }

    let instruction = Instruction {
        program_id,
        accounts,
        data: deposit_ix_data(lp_mint_amount, token_max_a, token_max_b),
    };
    Ok(instruction)
}