defituna_client/generated/instructions/
create_market_permissionless.rs

1//! This code was AUTOGENERATED using the codama library.
2//! Please DO NOT EDIT THIS FILE, instead use visitors
3//! to add features, then rerun codama to update it.
4//!
5//! <https://github.com/codama-idl/codama>
6//!
7
8use solana_pubkey::Pubkey;
9use borsh::BorshSerialize;
10use borsh::BorshDeserialize;
11
12pub const CREATE_MARKET_PERMISSIONLESS_DISCRIMINATOR: [u8; 8] = [72, 192, 190, 142, 105, 151, 2, 80];
13
14/// Accounts.
15#[derive(Debug)]
16pub struct CreateMarketPermissionless {
17      
18              
19          pub authority: solana_pubkey::Pubkey,
20          
21              
22          pub tuna_config: solana_pubkey::Pubkey,
23          
24              
25          pub market: solana_pubkey::Pubkey,
26          
27              
28          pub vault_a: solana_pubkey::Pubkey,
29          
30              
31          pub vault_b: solana_pubkey::Pubkey,
32          
33              
34          pub pool: solana_pubkey::Pubkey,
35          
36              
37          pub system_program: solana_pubkey::Pubkey,
38      }
39
40impl CreateMarketPermissionless {
41  pub fn instruction(&self, args: CreateMarketPermissionlessInstructionArgs) -> solana_instruction::Instruction {
42    self.instruction_with_remaining_accounts(args, &[])
43  }
44  #[allow(clippy::arithmetic_side_effects)]
45  #[allow(clippy::vec_init_then_push)]
46  pub fn instruction_with_remaining_accounts(&self, args: CreateMarketPermissionlessInstructionArgs, remaining_accounts: &[solana_instruction::AccountMeta]) -> solana_instruction::Instruction {
47    let mut accounts = Vec::with_capacity(7+ remaining_accounts.len());
48                            accounts.push(solana_instruction::AccountMeta::new(
49            self.authority,
50            true
51          ));
52                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
53            self.tuna_config,
54            false
55          ));
56                                          accounts.push(solana_instruction::AccountMeta::new(
57            self.market,
58            false
59          ));
60                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
61            self.vault_a,
62            false
63          ));
64                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
65            self.vault_b,
66            false
67          ));
68                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
69            self.pool,
70            false
71          ));
72                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
73            self.system_program,
74            false
75          ));
76                      accounts.extend_from_slice(remaining_accounts);
77    let mut data = borsh::to_vec(&CreateMarketPermissionlessInstructionData::new()).unwrap();
78          let mut args = borsh::to_vec(&args).unwrap();
79      data.append(&mut args);
80    
81    solana_instruction::Instruction {
82      program_id: crate::TUNA_ID,
83      accounts,
84      data,
85    }
86  }
87}
88
89#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
90#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
91 pub struct CreateMarketPermissionlessInstructionData {
92            discriminator: [u8; 8],
93            }
94
95impl CreateMarketPermissionlessInstructionData {
96  pub fn new() -> Self {
97    Self {
98                        discriminator: [72, 192, 190, 142, 105, 151, 2, 80],
99                                }
100  }
101}
102
103impl Default for CreateMarketPermissionlessInstructionData {
104  fn default() -> Self {
105    Self::new()
106  }
107}
108
109#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
110#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
111 pub struct CreateMarketPermissionlessInstructionArgs {
112                  pub address_lookup_table: Pubkey,
113      }
114
115
116/// Instruction builder for `CreateMarketPermissionless`.
117///
118/// ### Accounts:
119///
120                      ///   0. `[writable, signer]` authority
121          ///   1. `[]` tuna_config
122                ///   2. `[writable]` market
123          ///   3. `[]` vault_a
124          ///   4. `[]` vault_b
125          ///   5. `[]` pool
126                ///   6. `[optional]` system_program (default to `11111111111111111111111111111111`)
127#[derive(Clone, Debug, Default)]
128pub struct CreateMarketPermissionlessBuilder {
129            authority: Option<solana_pubkey::Pubkey>,
130                tuna_config: Option<solana_pubkey::Pubkey>,
131                market: Option<solana_pubkey::Pubkey>,
132                vault_a: Option<solana_pubkey::Pubkey>,
133                vault_b: Option<solana_pubkey::Pubkey>,
134                pool: Option<solana_pubkey::Pubkey>,
135                system_program: Option<solana_pubkey::Pubkey>,
136                        address_lookup_table: Option<Pubkey>,
137        __remaining_accounts: Vec<solana_instruction::AccountMeta>,
138}
139
140impl CreateMarketPermissionlessBuilder {
141  pub fn new() -> Self {
142    Self::default()
143  }
144            #[inline(always)]
145    pub fn authority(&mut self, authority: solana_pubkey::Pubkey) -> &mut Self {
146                        self.authority = Some(authority);
147                    self
148    }
149            #[inline(always)]
150    pub fn tuna_config(&mut self, tuna_config: solana_pubkey::Pubkey) -> &mut Self {
151                        self.tuna_config = Some(tuna_config);
152                    self
153    }
154            #[inline(always)]
155    pub fn market(&mut self, market: solana_pubkey::Pubkey) -> &mut Self {
156                        self.market = Some(market);
157                    self
158    }
159            #[inline(always)]
160    pub fn vault_a(&mut self, vault_a: solana_pubkey::Pubkey) -> &mut Self {
161                        self.vault_a = Some(vault_a);
162                    self
163    }
164            #[inline(always)]
165    pub fn vault_b(&mut self, vault_b: solana_pubkey::Pubkey) -> &mut Self {
166                        self.vault_b = Some(vault_b);
167                    self
168    }
169            #[inline(always)]
170    pub fn pool(&mut self, pool: solana_pubkey::Pubkey) -> &mut Self {
171                        self.pool = Some(pool);
172                    self
173    }
174            /// `[optional account, default to '11111111111111111111111111111111']`
175#[inline(always)]
176    pub fn system_program(&mut self, system_program: solana_pubkey::Pubkey) -> &mut Self {
177                        self.system_program = Some(system_program);
178                    self
179    }
180                    #[inline(always)]
181      pub fn address_lookup_table(&mut self, address_lookup_table: Pubkey) -> &mut Self {
182        self.address_lookup_table = Some(address_lookup_table);
183        self
184      }
185        /// Add an additional account to the instruction.
186  #[inline(always)]
187  pub fn add_remaining_account(&mut self, account: solana_instruction::AccountMeta) -> &mut Self {
188    self.__remaining_accounts.push(account);
189    self
190  }
191  /// Add additional accounts to the instruction.
192  #[inline(always)]
193  pub fn add_remaining_accounts(&mut self, accounts: &[solana_instruction::AccountMeta]) -> &mut Self {
194    self.__remaining_accounts.extend_from_slice(accounts);
195    self
196  }
197  #[allow(clippy::clone_on_copy)]
198  pub fn instruction(&self) -> solana_instruction::Instruction {
199    let accounts = CreateMarketPermissionless {
200                              authority: self.authority.expect("authority is not set"),
201                                        tuna_config: self.tuna_config.expect("tuna_config is not set"),
202                                        market: self.market.expect("market is not set"),
203                                        vault_a: self.vault_a.expect("vault_a is not set"),
204                                        vault_b: self.vault_b.expect("vault_b is not set"),
205                                        pool: self.pool.expect("pool is not set"),
206                                        system_program: self.system_program.unwrap_or(solana_pubkey::pubkey!("11111111111111111111111111111111")),
207                      };
208          let args = CreateMarketPermissionlessInstructionArgs {
209                                                              address_lookup_table: self.address_lookup_table.clone().expect("address_lookup_table is not set"),
210                                    };
211    
212    accounts.instruction_with_remaining_accounts(args, &self.__remaining_accounts)
213  }
214}
215
216  /// `create_market_permissionless` CPI accounts.
217  pub struct CreateMarketPermissionlessCpiAccounts<'a, 'b> {
218          
219                    
220              pub authority: &'b solana_account_info::AccountInfo<'a>,
221                
222                    
223              pub tuna_config: &'b solana_account_info::AccountInfo<'a>,
224                
225                    
226              pub market: &'b solana_account_info::AccountInfo<'a>,
227                
228                    
229              pub vault_a: &'b solana_account_info::AccountInfo<'a>,
230                
231                    
232              pub vault_b: &'b solana_account_info::AccountInfo<'a>,
233                
234                    
235              pub pool: &'b solana_account_info::AccountInfo<'a>,
236                
237                    
238              pub system_program: &'b solana_account_info::AccountInfo<'a>,
239            }
240
241/// `create_market_permissionless` CPI instruction.
242pub struct CreateMarketPermissionlessCpi<'a, 'b> {
243  /// The program to invoke.
244  pub __program: &'b solana_account_info::AccountInfo<'a>,
245      
246              
247          pub authority: &'b solana_account_info::AccountInfo<'a>,
248          
249              
250          pub tuna_config: &'b solana_account_info::AccountInfo<'a>,
251          
252              
253          pub market: &'b solana_account_info::AccountInfo<'a>,
254          
255              
256          pub vault_a: &'b solana_account_info::AccountInfo<'a>,
257          
258              
259          pub vault_b: &'b solana_account_info::AccountInfo<'a>,
260          
261              
262          pub pool: &'b solana_account_info::AccountInfo<'a>,
263          
264              
265          pub system_program: &'b solana_account_info::AccountInfo<'a>,
266            /// The arguments for the instruction.
267    pub __args: CreateMarketPermissionlessInstructionArgs,
268  }
269
270impl<'a, 'b> CreateMarketPermissionlessCpi<'a, 'b> {
271  pub fn new(
272    program: &'b solana_account_info::AccountInfo<'a>,
273          accounts: CreateMarketPermissionlessCpiAccounts<'a, 'b>,
274              args: CreateMarketPermissionlessInstructionArgs,
275      ) -> Self {
276    Self {
277      __program: program,
278              authority: accounts.authority,
279              tuna_config: accounts.tuna_config,
280              market: accounts.market,
281              vault_a: accounts.vault_a,
282              vault_b: accounts.vault_b,
283              pool: accounts.pool,
284              system_program: accounts.system_program,
285                    __args: args,
286          }
287  }
288  #[inline(always)]
289  pub fn invoke(&self) -> solana_program_error::ProgramResult {
290    self.invoke_signed_with_remaining_accounts(&[], &[])
291  }
292  #[inline(always)]
293  pub fn invoke_with_remaining_accounts(&self, remaining_accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]) -> solana_program_error::ProgramResult {
294    self.invoke_signed_with_remaining_accounts(&[], remaining_accounts)
295  }
296  #[inline(always)]
297  pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program_error::ProgramResult {
298    self.invoke_signed_with_remaining_accounts(signers_seeds, &[])
299  }
300  #[allow(clippy::arithmetic_side_effects)]
301  #[allow(clippy::clone_on_copy)]
302  #[allow(clippy::vec_init_then_push)]
303  pub fn invoke_signed_with_remaining_accounts(
304    &self,
305    signers_seeds: &[&[&[u8]]],
306    remaining_accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]
307  ) -> solana_program_error::ProgramResult {
308    let mut accounts = Vec::with_capacity(7+ remaining_accounts.len());
309                            accounts.push(solana_instruction::AccountMeta::new(
310            *self.authority.key,
311            true
312          ));
313                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
314            *self.tuna_config.key,
315            false
316          ));
317                                          accounts.push(solana_instruction::AccountMeta::new(
318            *self.market.key,
319            false
320          ));
321                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
322            *self.vault_a.key,
323            false
324          ));
325                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
326            *self.vault_b.key,
327            false
328          ));
329                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
330            *self.pool.key,
331            false
332          ));
333                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
334            *self.system_program.key,
335            false
336          ));
337                      remaining_accounts.iter().for_each(|remaining_account| {
338      accounts.push(solana_instruction::AccountMeta {
339          pubkey: *remaining_account.0.key,
340          is_signer: remaining_account.1,
341          is_writable: remaining_account.2,
342      })
343    });
344    let mut data = borsh::to_vec(&CreateMarketPermissionlessInstructionData::new()).unwrap();
345          let mut args = borsh::to_vec(&self.__args).unwrap();
346      data.append(&mut args);
347    
348    let instruction = solana_instruction::Instruction {
349      program_id: crate::TUNA_ID,
350      accounts,
351      data,
352    };
353    let mut account_infos = Vec::with_capacity(8 + remaining_accounts.len());
354    account_infos.push(self.__program.clone());
355                  account_infos.push(self.authority.clone());
356                        account_infos.push(self.tuna_config.clone());
357                        account_infos.push(self.market.clone());
358                        account_infos.push(self.vault_a.clone());
359                        account_infos.push(self.vault_b.clone());
360                        account_infos.push(self.pool.clone());
361                        account_infos.push(self.system_program.clone());
362              remaining_accounts.iter().for_each(|remaining_account| account_infos.push(remaining_account.0.clone()));
363
364    if signers_seeds.is_empty() {
365      solana_cpi::invoke(&instruction, &account_infos)
366    } else {
367      solana_cpi::invoke_signed(&instruction, &account_infos, signers_seeds)
368    }
369  }
370}
371
372/// Instruction builder for `CreateMarketPermissionless` via CPI.
373///
374/// ### Accounts:
375///
376                      ///   0. `[writable, signer]` authority
377          ///   1. `[]` tuna_config
378                ///   2. `[writable]` market
379          ///   3. `[]` vault_a
380          ///   4. `[]` vault_b
381          ///   5. `[]` pool
382          ///   6. `[]` system_program
383#[derive(Clone, Debug)]
384pub struct CreateMarketPermissionlessCpiBuilder<'a, 'b> {
385  instruction: Box<CreateMarketPermissionlessCpiBuilderInstruction<'a, 'b>>,
386}
387
388impl<'a, 'b> CreateMarketPermissionlessCpiBuilder<'a, 'b> {
389  pub fn new(program: &'b solana_account_info::AccountInfo<'a>) -> Self {
390    let instruction = Box::new(CreateMarketPermissionlessCpiBuilderInstruction {
391      __program: program,
392              authority: None,
393              tuna_config: None,
394              market: None,
395              vault_a: None,
396              vault_b: None,
397              pool: None,
398              system_program: None,
399                                            address_lookup_table: None,
400                    __remaining_accounts: Vec::new(),
401    });
402    Self { instruction }
403  }
404      #[inline(always)]
405    pub fn authority(&mut self, authority: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
406                        self.instruction.authority = Some(authority);
407                    self
408    }
409      #[inline(always)]
410    pub fn tuna_config(&mut self, tuna_config: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
411                        self.instruction.tuna_config = Some(tuna_config);
412                    self
413    }
414      #[inline(always)]
415    pub fn market(&mut self, market: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
416                        self.instruction.market = Some(market);
417                    self
418    }
419      #[inline(always)]
420    pub fn vault_a(&mut self, vault_a: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
421                        self.instruction.vault_a = Some(vault_a);
422                    self
423    }
424      #[inline(always)]
425    pub fn vault_b(&mut self, vault_b: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
426                        self.instruction.vault_b = Some(vault_b);
427                    self
428    }
429      #[inline(always)]
430    pub fn pool(&mut self, pool: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
431                        self.instruction.pool = Some(pool);
432                    self
433    }
434      #[inline(always)]
435    pub fn system_program(&mut self, system_program: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
436                        self.instruction.system_program = Some(system_program);
437                    self
438    }
439                    #[inline(always)]
440      pub fn address_lookup_table(&mut self, address_lookup_table: Pubkey) -> &mut Self {
441        self.instruction.address_lookup_table = Some(address_lookup_table);
442        self
443      }
444        /// Add an additional account to the instruction.
445  #[inline(always)]
446  pub fn add_remaining_account(&mut self, account: &'b solana_account_info::AccountInfo<'a>, is_writable: bool, is_signer: bool) -> &mut Self {
447    self.instruction.__remaining_accounts.push((account, is_writable, is_signer));
448    self
449  }
450  /// Add additional accounts to the instruction.
451  ///
452  /// Each account is represented by a tuple of the `AccountInfo`, a `bool` indicating whether the account is writable or not,
453  /// and a `bool` indicating whether the account is a signer or not.
454  #[inline(always)]
455  pub fn add_remaining_accounts(&mut self, accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]) -> &mut Self {
456    self.instruction.__remaining_accounts.extend_from_slice(accounts);
457    self
458  }
459  #[inline(always)]
460  pub fn invoke(&self) -> solana_program_error::ProgramResult {
461    self.invoke_signed(&[])
462  }
463  #[allow(clippy::clone_on_copy)]
464  #[allow(clippy::vec_init_then_push)]
465  pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program_error::ProgramResult {
466          let args = CreateMarketPermissionlessInstructionArgs {
467                                                              address_lookup_table: self.instruction.address_lookup_table.clone().expect("address_lookup_table is not set"),
468                                    };
469        let instruction = CreateMarketPermissionlessCpi {
470        __program: self.instruction.__program,
471                  
472          authority: self.instruction.authority.expect("authority is not set"),
473                  
474          tuna_config: self.instruction.tuna_config.expect("tuna_config is not set"),
475                  
476          market: self.instruction.market.expect("market is not set"),
477                  
478          vault_a: self.instruction.vault_a.expect("vault_a is not set"),
479                  
480          vault_b: self.instruction.vault_b.expect("vault_b is not set"),
481                  
482          pool: self.instruction.pool.expect("pool is not set"),
483                  
484          system_program: self.instruction.system_program.expect("system_program is not set"),
485                          __args: args,
486            };
487    instruction.invoke_signed_with_remaining_accounts(signers_seeds, &self.instruction.__remaining_accounts)
488  }
489}
490
491#[derive(Clone, Debug)]
492struct CreateMarketPermissionlessCpiBuilderInstruction<'a, 'b> {
493  __program: &'b solana_account_info::AccountInfo<'a>,
494            authority: Option<&'b solana_account_info::AccountInfo<'a>>,
495                tuna_config: Option<&'b solana_account_info::AccountInfo<'a>>,
496                market: Option<&'b solana_account_info::AccountInfo<'a>>,
497                vault_a: Option<&'b solana_account_info::AccountInfo<'a>>,
498                vault_b: Option<&'b solana_account_info::AccountInfo<'a>>,
499                pool: Option<&'b solana_account_info::AccountInfo<'a>>,
500                system_program: Option<&'b solana_account_info::AccountInfo<'a>>,
501                        address_lookup_table: Option<Pubkey>,
502        /// Additional instruction accounts `(AccountInfo, is_writable, is_signer)`.
503  __remaining_accounts: Vec<(&'b solana_account_info::AccountInfo<'a>, bool, bool)>,
504}
505
defituna_client/generated/instructions/create_market_permissionless.rs

defituna_client/generated/instructions/
create_market_permissionless.rs
