carbon-marginfi-v2-decoder 1.0.0

MarginfiV2 Decoder
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

//! This code was AUTOGENERATED using the Codama library.
use carbon_core::{account_utils::next_account, deserialize::ArrangeAccounts};
/// (permissionless) Initialize a Kamino obligation for a marginfi bank
/// * amount - In token, in native decimals. Must be >10 (i.e. 10 lamports, not
///   10 tokens). Lost
///
/// forever. Generally, try to make this the equivalent of around $1, in case
/// Kamino ever rounds small balances down to zero.
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, borsh::BorshSerialize, borsh::BorshDeserialize, PartialEq)]
pub struct KaminoInitObligation {
    pub amount: u64,
}

#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KaminoInitObligationInstructionAccounts {
    pub fee_payer: solana_pubkey::Pubkey,
    pub bank: solana_pubkey::Pubkey,
    pub signer_token_account: solana_pubkey::Pubkey,
    pub liquidity_vault_authority: solana_pubkey::Pubkey,
    pub liquidity_vault: solana_pubkey::Pubkey,
    pub integration_acc2: solana_pubkey::Pubkey,
    pub user_metadata: solana_pubkey::Pubkey,
    pub lending_market: solana_pubkey::Pubkey,
    pub lending_market_authority: solana_pubkey::Pubkey,
    pub integration_acc1: solana_pubkey::Pubkey,
    pub mint: solana_pubkey::Pubkey,
    pub reserve_liquidity_supply: solana_pubkey::Pubkey,
    pub reserve_collateral_mint: solana_pubkey::Pubkey,
    pub reserve_destination_deposit_collateral: solana_pubkey::Pubkey,
    pub pyth_oracle: Option<solana_pubkey::Pubkey>,
    pub switchboard_price_oracle: Option<solana_pubkey::Pubkey>,
    pub switchboard_twap_oracle: Option<solana_pubkey::Pubkey>,
    pub scope_prices: Option<solana_pubkey::Pubkey>,
    pub obligation_farm_user_state: Option<solana_pubkey::Pubkey>,
    pub reserve_farm_state: Option<solana_pubkey::Pubkey>,
    pub kamino_program: solana_pubkey::Pubkey,
    pub farms_program: solana_pubkey::Pubkey,
    pub collateral_token_program: solana_pubkey::Pubkey,
    pub liquidity_token_program: solana_pubkey::Pubkey,
    pub instruction_sysvar_account: solana_pubkey::Pubkey,
    pub rent: solana_pubkey::Pubkey,
    pub system_program: solana_pubkey::Pubkey,
    pub remaining: Vec<solana_instruction::AccountMeta>,
}

impl KaminoInitObligation {
    pub fn decode(data: &[u8]) -> Option<Self> {
        if data.len() < 8 {
            return None;
        }
        let discriminator = &data[0..8];
        if discriminator != [253, 177, 160, 225, 70, 156, 217, 109] {
            return None;
        }

        let mut data_slice = data;

        data_slice = &data_slice[8..];

        borsh::BorshDeserialize::deserialize(&mut data_slice).ok()
    }
}

impl ArrangeAccounts for KaminoInitObligation {
    type ArrangedAccounts = KaminoInitObligationInstructionAccounts;

    fn arrange_accounts(
        accounts: &[solana_instruction::AccountMeta],
    ) -> Option<Self::ArrangedAccounts> {
        let mut iter = accounts.iter();

        let fee_payer = next_account(&mut iter)?;
        let bank = next_account(&mut iter)?;
        let signer_token_account = next_account(&mut iter)?;
        let liquidity_vault_authority = next_account(&mut iter)?;
        let liquidity_vault = next_account(&mut iter)?;
        let integration_acc2 = next_account(&mut iter)?;
        let user_metadata = next_account(&mut iter)?;
        let lending_market = next_account(&mut iter)?;
        let lending_market_authority = next_account(&mut iter)?;
        let integration_acc1 = next_account(&mut iter)?;
        let mint = next_account(&mut iter)?;
        let reserve_liquidity_supply = next_account(&mut iter)?;
        let reserve_collateral_mint = next_account(&mut iter)?;
        let reserve_destination_deposit_collateral = next_account(&mut iter)?;
        let pyth_oracle = next_account(&mut iter);
        let switchboard_price_oracle = next_account(&mut iter);
        let switchboard_twap_oracle = next_account(&mut iter);
        let scope_prices = next_account(&mut iter);
        let obligation_farm_user_state = next_account(&mut iter);
        let reserve_farm_state = next_account(&mut iter);
        let kamino_program = next_account(&mut iter)?;
        let farms_program = next_account(&mut iter)?;
        let collateral_token_program = next_account(&mut iter)?;
        let liquidity_token_program = next_account(&mut iter)?;
        let instruction_sysvar_account = next_account(&mut iter)?;
        let rent = next_account(&mut iter)?;
        let system_program = next_account(&mut iter)?;

        let remaining = iter.as_slice();

        Some(KaminoInitObligationInstructionAccounts {
            fee_payer,
            bank,
            signer_token_account,
            liquidity_vault_authority,
            liquidity_vault,
            integration_acc2,
            user_metadata,
            lending_market,
            lending_market_authority,
            integration_acc1,
            mint,
            reserve_liquidity_supply,
            reserve_collateral_mint,
            reserve_destination_deposit_collateral,
            pyth_oracle,
            switchboard_price_oracle,
            switchboard_twap_oracle,
            scope_prices,
            obligation_farm_user_state,
            reserve_farm_state,
            kamino_program,
            farms_program,
            collateral_token_program,
            liquidity_token_program,
            instruction_sysvar_account,
            rent,
            system_program,
            remaining: remaining.to_vec(),
        })
    }
}