carbon_score_decoder/instructions/
process_rearm.rs1use carbon_core::CarbonDeserialize;
3use carbon_core::account_utils::next_account;
4use carbon_core::borsh;
5use carbon_core::deserialize::ArrangeAccounts;
6use carbon_core::deserialize::CarbonDeserialize;
7
8#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9#[derive(Debug, Clone, borsh::BorshSerialize, CarbonDeserialize, PartialEq, Eq, Hash)]
10pub struct ProcessRearm {
11 pub staking_bump: u8,
12 pub scorevars_bump: u8,
13 pub scorevars_ship_bump: u8,
14 pub escrow_auth_bump: u8,
15 pub escrow_bump: u8,
16 pub arms_quantity: u64,
17}
18
19#[derive(Debug, Clone, PartialEq)]
20#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
21pub struct ProcessRearmInstructionAccounts {
22 pub token_owner_account: solana_pubkey::Pubkey,
23 pub player_account: solana_pubkey::Pubkey,
24 pub ship_staking_account: solana_pubkey::Pubkey,
25 pub score_vars_account: solana_pubkey::Pubkey,
26 pub score_vars_ship_account: solana_pubkey::Pubkey,
27 pub escrow_authority: solana_pubkey::Pubkey,
28 pub system_program: solana_pubkey::Pubkey,
29 pub token_program: solana_pubkey::Pubkey,
30 pub clock: solana_pubkey::Pubkey,
31 pub rent: solana_pubkey::Pubkey,
32 pub ship_mint: solana_pubkey::Pubkey,
33 pub arms_mint: solana_pubkey::Pubkey,
34 pub arms_token_account_source: solana_pubkey::Pubkey,
35 pub arms_token_account_escrow: solana_pubkey::Pubkey,
36 pub remaining: Vec<solana_instruction::AccountMeta>,
37}
38
39impl ProcessRearm {
40 pub fn decode(data: &[u8]) -> Option<Self> {
41 if data.len() < 8 {
42 return None;
43 }
44 let discriminator = &data[0..8];
45 if discriminator != &[66, 135, 30, 194, 157, 219, 33, 219] {
46 return None;
47 }
48
49 let data_slice = data;
50
51 let data_slice = &data_slice[8..];
52
53 Self::deserialize(data_slice)
54 }
55}
56
57impl ArrangeAccounts for ProcessRearm {
58 type ArrangedAccounts = ProcessRearmInstructionAccounts;
59
60 fn arrange_accounts(
61 accounts: &[solana_instruction::AccountMeta],
62 ) -> Option<Self::ArrangedAccounts> {
63 let mut iter = accounts.iter();
64
65 let token_owner_account = next_account(&mut iter)?;
66 let player_account = next_account(&mut iter)?;
67 let ship_staking_account = next_account(&mut iter)?;
68 let score_vars_account = next_account(&mut iter)?;
69 let score_vars_ship_account = next_account(&mut iter)?;
70 let escrow_authority = next_account(&mut iter)?;
71 let system_program = next_account(&mut iter)?;
72 let token_program = next_account(&mut iter)?;
73 let clock = next_account(&mut iter)?;
74 let rent = next_account(&mut iter)?;
75 let ship_mint = next_account(&mut iter)?;
76 let arms_mint = next_account(&mut iter)?;
77 let arms_token_account_source = next_account(&mut iter)?;
78 let arms_token_account_escrow = next_account(&mut iter)?;
79
80 let remaining = iter.as_slice();
81
82 Some(ProcessRearmInstructionAccounts {
83 token_owner_account,
84 player_account,
85 ship_staking_account,
86 score_vars_account,
87 score_vars_ship_account,
88 escrow_authority,
89 system_program,
90 token_program,
91 clock,
92 rent,
93 ship_mint,
94 arms_mint,
95 arms_token_account_source,
96 arms_token_account_escrow,
97 remaining: remaining.to_vec(),
98 })
99 }
100}