carbon-zeta-decoder 2.0.0

Zeta Program 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 {
    crate::types::{OrderType, Side},
    carbon_core::{account_utils::next_account, deserialize::ArrangeAccounts},
};
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Debug, Clone, borsh::BorshSerialize, borsh::BorshDeserialize, PartialEq)]
pub struct PlaceOrderV4 {
    pub price: u64,
    pub size: u64,
    pub side: Side,
    pub order_type: OrderType,
    pub client_order_id: Option<u64>,
    pub tag: Option<String>,
    pub tif_offset: Option<u16>,
}

#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct PlaceOrderV4InstructionAccounts {
    pub state: solana_pubkey::Pubkey,
    pub zeta_group: solana_pubkey::Pubkey,
    pub margin_account: solana_pubkey::Pubkey,
    pub authority: solana_pubkey::Pubkey,
    pub dex_program: solana_pubkey::Pubkey,
    pub token_program: solana_pubkey::Pubkey,
    pub serum_authority: solana_pubkey::Pubkey,
    pub greeks: solana_pubkey::Pubkey,
    pub open_orders: solana_pubkey::Pubkey,
    pub rent: solana_pubkey::Pubkey,
    pub market: solana_pubkey::Pubkey,
    pub request_queue: solana_pubkey::Pubkey,
    pub event_queue: solana_pubkey::Pubkey,
    pub bids: solana_pubkey::Pubkey,
    pub asks: solana_pubkey::Pubkey,
    pub order_payer_token_account: solana_pubkey::Pubkey,
    pub coin_vault: solana_pubkey::Pubkey,
    pub pc_vault: solana_pubkey::Pubkey,
    pub coin_wallet: solana_pubkey::Pubkey,
    pub pc_wallet: solana_pubkey::Pubkey,
    pub oracle: solana_pubkey::Pubkey,
    pub oracle_backup_feed: solana_pubkey::Pubkey,
    pub oracle_backup_program: solana_pubkey::Pubkey,
    pub market_node: solana_pubkey::Pubkey,
    pub market_mint: solana_pubkey::Pubkey,
    pub mint_authority: solana_pubkey::Pubkey,
    pub remaining: Vec<solana_instruction::AccountMeta>,
}

impl PlaceOrderV4 {
    pub fn decode(data: &[u8]) -> Option<Self> {
        if data.len() < 8 {
            return None;
        }
        let discriminator = &data[0..8];
        if discriminator != [243, 248, 213, 143, 184, 79, 41, 73] {
            return None;
        }

        let mut data_slice = data;

        data_slice = &data_slice[8..];

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

impl ArrangeAccounts for PlaceOrderV4 {
    type ArrangedAccounts = PlaceOrderV4InstructionAccounts;

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

        let state = next_account(&mut iter)?;
        let zeta_group = next_account(&mut iter)?;
        let margin_account = next_account(&mut iter)?;
        let authority = next_account(&mut iter)?;
        let dex_program = next_account(&mut iter)?;
        let token_program = next_account(&mut iter)?;
        let serum_authority = next_account(&mut iter)?;
        let greeks = next_account(&mut iter)?;
        let open_orders = next_account(&mut iter)?;
        let rent = next_account(&mut iter)?;
        let market = next_account(&mut iter)?;
        let request_queue = next_account(&mut iter)?;
        let event_queue = next_account(&mut iter)?;
        let bids = next_account(&mut iter)?;
        let asks = next_account(&mut iter)?;
        let order_payer_token_account = next_account(&mut iter)?;
        let coin_vault = next_account(&mut iter)?;
        let pc_vault = next_account(&mut iter)?;
        let coin_wallet = next_account(&mut iter)?;
        let pc_wallet = next_account(&mut iter)?;
        let oracle = next_account(&mut iter)?;
        let oracle_backup_feed = next_account(&mut iter)?;
        let oracle_backup_program = next_account(&mut iter)?;
        let market_node = next_account(&mut iter)?;
        let market_mint = next_account(&mut iter)?;
        let mint_authority = next_account(&mut iter)?;

        let remaining = iter.as_slice();

        Some(PlaceOrderV4InstructionAccounts {
            state,
            zeta_group,
            margin_account,
            authority,
            dex_program,
            token_program,
            serum_authority,
            greeks,
            open_orders,
            rent,
            market,
            request_queue,
            event_queue,
            bids,
            asks,
            order_payer_token_account,
            coin_vault,
            pc_vault,
            coin_wallet,
            pc_wallet,
            oracle,
            oracle_backup_feed,
            oracle_backup_program,
            market_node,
            market_mint,
            mint_authority,
            remaining: remaining.to_vec(),
        })
    }
}