klend-interface 0.6.0

Instruction builders for Kamino Lending (klend) — no anchor-lang dependency
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

use borsh::BorshSerialize;
use solana_instruction::{AccountMeta, Instruction};
use solana_pubkey::Pubkey;

use crate::{
    discriminators, util::*, FARMS_PROGRAM_ID, KLEND_PROGRAM_ID, SYSVAR_INSTRUCTIONS_ID,
    TOKEN_PROGRAM_ID,
};

// ---------------------------------------------------------------------------
// deposit_and_withdraw
// ---------------------------------------------------------------------------

pub struct DepositAndWithdrawAccounts {
    // DepositReserveLiquidityAndObligationCollateral accounts
    pub owner: Pubkey,
    pub obligation: Pubkey,
    pub lending_market: Pubkey,
    pub lending_market_authority: Pubkey,
    pub reserve: Pubkey,
    pub reserve_liquidity_mint: Pubkey,
    pub reserve_liquidity_supply: Pubkey,
    pub reserve_collateral_mint: Pubkey,
    pub reserve_destination_deposit_collateral: Pubkey,
    pub user_source_liquidity: Pubkey,
    pub placeholder_user_destination_collateral: Option<Pubkey>,
    pub liquidity_token_program: Pubkey,

    // WithdrawObligationCollateralAndRedeemReserveCollateral accounts
    pub withdraw_owner: Pubkey,
    pub withdraw_obligation: Pubkey,
    pub withdraw_lending_market: Pubkey,
    pub withdraw_lending_market_authority: Pubkey,
    pub withdraw_reserve: Pubkey,
    pub withdraw_reserve_liquidity_mint: Pubkey,
    pub withdraw_reserve_source_collateral: Pubkey,
    pub withdraw_reserve_collateral_mint: Pubkey,
    pub withdraw_reserve_liquidity_supply: Pubkey,
    pub withdraw_user_destination_liquidity: Pubkey,
    pub withdraw_placeholder_user_destination_collateral: Option<Pubkey>,
    pub withdraw_liquidity_token_program: Pubkey,

    // Farms accounts
    pub deposit_obligation_farm_user_state: Option<Pubkey>,
    pub deposit_reserve_farm_state: Option<Pubkey>,
    pub withdraw_obligation_farm_user_state: Option<Pubkey>,
    pub withdraw_reserve_farm_state: Option<Pubkey>,
}

pub fn deposit_and_withdraw(
    accounts: DepositAndWithdrawAccounts,
    liquidity_amount: u64,
    withdraw_collateral_amount: u64,
    remaining_accounts: Vec<AccountMeta>,
) -> Instruction {
    #[derive(BorshSerialize)]
    struct Args {
        liquidity_amount: u64,
        withdraw_collateral_amount: u64,
    }

    let args = Args {
        liquidity_amount,
        withdraw_collateral_amount,
    };
    let mut data = discriminators::DEPOSIT_AND_WITHDRAW.to_vec();
    args.serialize(&mut data).unwrap();

    let mut account_metas = vec![
        // DepositReserveLiquidityAndObligationCollateral
        signer_writable(accounts.owner),
        writable(accounts.obligation),
        readonly(accounts.lending_market),
        readonly(accounts.lending_market_authority),
        writable(accounts.reserve),
        readonly(accounts.reserve_liquidity_mint),
        writable(accounts.reserve_liquidity_supply),
        writable(accounts.reserve_collateral_mint),
        writable(accounts.reserve_destination_deposit_collateral),
        writable(accounts.user_source_liquidity),
        optional_account(
            &KLEND_PROGRAM_ID,
            accounts.placeholder_user_destination_collateral,
            false,
        ),
        readonly(TOKEN_PROGRAM_ID),
        readonly(accounts.liquidity_token_program),
        readonly(SYSVAR_INSTRUCTIONS_ID),
        // WithdrawObligationCollateralAndRedeemReserveCollateral
        signer_writable(accounts.withdraw_owner),
        writable(accounts.withdraw_obligation),
        readonly(accounts.withdraw_lending_market),
        readonly(accounts.withdraw_lending_market_authority),
        writable(accounts.withdraw_reserve),
        readonly(accounts.withdraw_reserve_liquidity_mint),
        writable(accounts.withdraw_reserve_source_collateral),
        writable(accounts.withdraw_reserve_collateral_mint),
        writable(accounts.withdraw_reserve_liquidity_supply),
        writable(accounts.withdraw_user_destination_liquidity),
        optional_account(
            &KLEND_PROGRAM_ID,
            accounts.withdraw_placeholder_user_destination_collateral,
            false,
        ),
        readonly(TOKEN_PROGRAM_ID),
        readonly(accounts.withdraw_liquidity_token_program),
        readonly(SYSVAR_INSTRUCTIONS_ID),
        // Farms
        optional_account(
            &KLEND_PROGRAM_ID,
            accounts.deposit_obligation_farm_user_state,
            true,
        ),
        optional_account(&KLEND_PROGRAM_ID, accounts.deposit_reserve_farm_state, true),
        optional_account(
            &KLEND_PROGRAM_ID,
            accounts.withdraw_obligation_farm_user_state,
            true,
        ),
        optional_account(
            &KLEND_PROGRAM_ID,
            accounts.withdraw_reserve_farm_state,
            true,
        ),
        readonly(FARMS_PROGRAM_ID),
    ];

    account_metas.extend(remaining_accounts);

    Instruction {
        program_id: KLEND_PROGRAM_ID,
        accounts: account_metas,
        data,
    }
}