carbon_boop_decoder/instructions/
create_raydium_random_pool.rs1use carbon_core::{account_utils::next_account, deserialize::ArrangeAccounts};
3#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
4#[derive(Debug, Clone, borsh::BorshSerialize, borsh::BorshDeserialize, PartialEq)]
5pub struct CreateRaydiumRandomPool {}
6
7#[derive(Debug, Clone, PartialEq)]
8#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
9pub struct CreateRaydiumRandomPoolInstructionAccounts {
10 pub cpmm_program: solana_pubkey::Pubkey,
11 pub amm_config: solana_pubkey::Pubkey,
12 pub authority: solana_pubkey::Pubkey,
13 pub pool_state: solana_pubkey::Pubkey,
14 pub token0_mint: solana_pubkey::Pubkey,
15 pub token1_mint: solana_pubkey::Pubkey,
16 pub lp_mint: solana_pubkey::Pubkey,
17 pub vault_authority: solana_pubkey::Pubkey,
18 pub bonding_curve: solana_pubkey::Pubkey,
19 pub bonding_curve_vault: solana_pubkey::Pubkey,
20 pub bonding_curve_wsol_vault: solana_pubkey::Pubkey,
21 pub creator_lp_token: solana_pubkey::Pubkey,
22 pub token0_vault: solana_pubkey::Pubkey,
23 pub token1_vault: solana_pubkey::Pubkey,
24 pub create_pool_fee: solana_pubkey::Pubkey,
25 pub observation_state: solana_pubkey::Pubkey,
26 pub operator: solana_pubkey::Pubkey,
27 pub config: solana_pubkey::Pubkey,
28 pub token_program: solana_pubkey::Pubkey,
29 pub associated_token_program: solana_pubkey::Pubkey,
30 pub system_program: solana_pubkey::Pubkey,
31 pub rent: solana_pubkey::Pubkey,
32 pub remaining: Vec<solana_instruction::AccountMeta>,
33}
34
35impl CreateRaydiumRandomPool {
36 pub fn decode(data: &[u8]) -> Option<Self> {
37 if data.len() < 8 {
38 return None;
39 }
40 let discriminator = &data[0..8];
41 if discriminator != [78, 44, 173, 29, 132, 180, 4, 172] {
42 return None;
43 }
44
45 let mut data_slice = data;
46
47 data_slice = &data_slice[8..];
48
49 borsh::BorshDeserialize::deserialize(&mut data_slice).ok()
50 }
51}
52
53impl ArrangeAccounts for CreateRaydiumRandomPool {
54 type ArrangedAccounts = CreateRaydiumRandomPoolInstructionAccounts;
55
56 fn arrange_accounts(
57 accounts: &[solana_instruction::AccountMeta],
58 ) -> Option<Self::ArrangedAccounts> {
59 let mut iter = accounts.iter();
60
61 let cpmm_program = next_account(&mut iter)?;
62 let amm_config = next_account(&mut iter)?;
63 let authority = next_account(&mut iter)?;
64 let pool_state = next_account(&mut iter)?;
65 let token0_mint = next_account(&mut iter)?;
66 let token1_mint = next_account(&mut iter)?;
67 let lp_mint = next_account(&mut iter)?;
68 let vault_authority = next_account(&mut iter)?;
69 let bonding_curve = next_account(&mut iter)?;
70 let bonding_curve_vault = next_account(&mut iter)?;
71 let bonding_curve_wsol_vault = next_account(&mut iter)?;
72 let creator_lp_token = next_account(&mut iter)?;
73 let token0_vault = next_account(&mut iter)?;
74 let token1_vault = next_account(&mut iter)?;
75 let create_pool_fee = next_account(&mut iter)?;
76 let observation_state = next_account(&mut iter)?;
77 let operator = next_account(&mut iter)?;
78 let config = next_account(&mut iter)?;
79 let token_program = next_account(&mut iter)?;
80 let associated_token_program = next_account(&mut iter)?;
81 let system_program = next_account(&mut iter)?;
82 let rent = next_account(&mut iter)?;
83
84 let remaining = iter.as_slice();
85
86 Some(CreateRaydiumRandomPoolInstructionAccounts {
87 cpmm_program,
88 amm_config,
89 authority,
90 pool_state,
91 token0_mint,
92 token1_mint,
93 lp_mint,
94 vault_authority,
95 bonding_curve,
96 bonding_curve_vault,
97 bonding_curve_wsol_vault,
98 creator_lp_token,
99 token0_vault,
100 token1_vault,
101 create_pool_fee,
102 observation_state,
103 operator,
104 config,
105 token_program,
106 associated_token_program,
107 system_program,
108 rent,
109 remaining: remaining.to_vec(),
110 })
111 }
112}