defituna_client/generated/instructions/
open_tuna_spot_position.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 crate::generated::types::PoolToken;
9use borsh::BorshSerialize;
10use borsh::BorshDeserialize;
11
12pub const OPEN_TUNA_SPOT_POSITION_DISCRIMINATOR: [u8; 8] = [87, 208, 173, 48, 231, 62, 210, 220];
13
14/// Accounts.
15#[derive(Debug)]
16pub struct OpenTunaSpotPosition {
17            /// 
18/// TUNA accounts
19/// 
20
21    
22              
23          pub authority: solana_pubkey::Pubkey,
24          
25              
26          pub mint_a: solana_pubkey::Pubkey,
27          
28              
29          pub mint_b: solana_pubkey::Pubkey,
30          
31              
32          pub token_program_a: solana_pubkey::Pubkey,
33          
34              
35          pub token_program_b: solana_pubkey::Pubkey,
36          
37              
38          pub market: solana_pubkey::Pubkey,
39          
40              
41          pub tuna_position: solana_pubkey::Pubkey,
42          
43              
44          pub tuna_position_ata_a: solana_pubkey::Pubkey,
45          
46              
47          pub tuna_position_ata_b: solana_pubkey::Pubkey,
48                /// 
49/// Fusion or Orca accounts
50/// 
51
52    
53              
54          pub pool: solana_pubkey::Pubkey,
55                /// 
56/// Other accounts
57/// 
58
59    
60              
61          pub system_program: solana_pubkey::Pubkey,
62          
63              
64          pub associated_token_program: solana_pubkey::Pubkey,
65      }
66
67impl OpenTunaSpotPosition {
68  pub fn instruction(&self, args: OpenTunaSpotPositionInstructionArgs) -> solana_instruction::Instruction {
69    self.instruction_with_remaining_accounts(args, &[])
70  }
71  #[allow(clippy::arithmetic_side_effects)]
72  #[allow(clippy::vec_init_then_push)]
73  pub fn instruction_with_remaining_accounts(&self, args: OpenTunaSpotPositionInstructionArgs, remaining_accounts: &[solana_instruction::AccountMeta]) -> solana_instruction::Instruction {
74    let mut accounts = Vec::with_capacity(12+ remaining_accounts.len());
75                            accounts.push(solana_instruction::AccountMeta::new(
76            self.authority,
77            true
78          ));
79                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
80            self.mint_a,
81            false
82          ));
83                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
84            self.mint_b,
85            false
86          ));
87                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
88            self.token_program_a,
89            false
90          ));
91                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
92            self.token_program_b,
93            false
94          ));
95                                          accounts.push(solana_instruction::AccountMeta::new(
96            self.market,
97            false
98          ));
99                                          accounts.push(solana_instruction::AccountMeta::new(
100            self.tuna_position,
101            false
102          ));
103                                          accounts.push(solana_instruction::AccountMeta::new(
104            self.tuna_position_ata_a,
105            false
106          ));
107                                          accounts.push(solana_instruction::AccountMeta::new(
108            self.tuna_position_ata_b,
109            false
110          ));
111                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
112            self.pool,
113            false
114          ));
115                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
116            self.system_program,
117            false
118          ));
119                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
120            self.associated_token_program,
121            false
122          ));
123                      accounts.extend_from_slice(remaining_accounts);
124    let mut data = borsh::to_vec(&OpenTunaSpotPositionInstructionData::new()).unwrap();
125          let mut args = borsh::to_vec(&args).unwrap();
126      data.append(&mut args);
127    
128    solana_instruction::Instruction {
129      program_id: crate::TUNA_ID,
130      accounts,
131      data,
132    }
133  }
134}
135
136#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
137#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
138 pub struct OpenTunaSpotPositionInstructionData {
139            discriminator: [u8; 8],
140                  }
141
142impl OpenTunaSpotPositionInstructionData {
143  pub fn new() -> Self {
144    Self {
145                        discriminator: [87, 208, 173, 48, 231, 62, 210, 220],
146                                              }
147  }
148}
149
150impl Default for OpenTunaSpotPositionInstructionData {
151  fn default() -> Self {
152    Self::new()
153  }
154}
155
156#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
157#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
158 pub struct OpenTunaSpotPositionInstructionArgs {
159                  pub position_token: PoolToken,
160                pub collateral_token: PoolToken,
161      }
162
163
164/// Instruction builder for `OpenTunaSpotPosition`.
165///
166/// ### Accounts:
167///
168                      ///   0. `[writable, signer]` authority
169          ///   1. `[]` mint_a
170          ///   2. `[]` mint_b
171          ///   3. `[]` token_program_a
172          ///   4. `[]` token_program_b
173                ///   5. `[writable]` market
174                ///   6. `[writable]` tuna_position
175                ///   7. `[writable]` tuna_position_ata_a
176                ///   8. `[writable]` tuna_position_ata_b
177          ///   9. `[]` pool
178                ///   10. `[optional]` system_program (default to `11111111111111111111111111111111`)
179          ///   11. `[]` associated_token_program
180#[derive(Clone, Debug, Default)]
181pub struct OpenTunaSpotPositionBuilder {
182            authority: Option<solana_pubkey::Pubkey>,
183                mint_a: Option<solana_pubkey::Pubkey>,
184                mint_b: Option<solana_pubkey::Pubkey>,
185                token_program_a: Option<solana_pubkey::Pubkey>,
186                token_program_b: Option<solana_pubkey::Pubkey>,
187                market: Option<solana_pubkey::Pubkey>,
188                tuna_position: Option<solana_pubkey::Pubkey>,
189                tuna_position_ata_a: Option<solana_pubkey::Pubkey>,
190                tuna_position_ata_b: Option<solana_pubkey::Pubkey>,
191                pool: Option<solana_pubkey::Pubkey>,
192                system_program: Option<solana_pubkey::Pubkey>,
193                associated_token_program: Option<solana_pubkey::Pubkey>,
194                        position_token: Option<PoolToken>,
195                collateral_token: Option<PoolToken>,
196        __remaining_accounts: Vec<solana_instruction::AccountMeta>,
197}
198
199impl OpenTunaSpotPositionBuilder {
200  pub fn new() -> Self {
201    Self::default()
202  }
203            /// 
204/// TUNA accounts
205/// 
206#[inline(always)]
207    pub fn authority(&mut self, authority: solana_pubkey::Pubkey) -> &mut Self {
208                        self.authority = Some(authority);
209                    self
210    }
211            #[inline(always)]
212    pub fn mint_a(&mut self, mint_a: solana_pubkey::Pubkey) -> &mut Self {
213                        self.mint_a = Some(mint_a);
214                    self
215    }
216            #[inline(always)]
217    pub fn mint_b(&mut self, mint_b: solana_pubkey::Pubkey) -> &mut Self {
218                        self.mint_b = Some(mint_b);
219                    self
220    }
221            #[inline(always)]
222    pub fn token_program_a(&mut self, token_program_a: solana_pubkey::Pubkey) -> &mut Self {
223                        self.token_program_a = Some(token_program_a);
224                    self
225    }
226            #[inline(always)]
227    pub fn token_program_b(&mut self, token_program_b: solana_pubkey::Pubkey) -> &mut Self {
228                        self.token_program_b = Some(token_program_b);
229                    self
230    }
231            #[inline(always)]
232    pub fn market(&mut self, market: solana_pubkey::Pubkey) -> &mut Self {
233                        self.market = Some(market);
234                    self
235    }
236            #[inline(always)]
237    pub fn tuna_position(&mut self, tuna_position: solana_pubkey::Pubkey) -> &mut Self {
238                        self.tuna_position = Some(tuna_position);
239                    self
240    }
241            #[inline(always)]
242    pub fn tuna_position_ata_a(&mut self, tuna_position_ata_a: solana_pubkey::Pubkey) -> &mut Self {
243                        self.tuna_position_ata_a = Some(tuna_position_ata_a);
244                    self
245    }
246            #[inline(always)]
247    pub fn tuna_position_ata_b(&mut self, tuna_position_ata_b: solana_pubkey::Pubkey) -> &mut Self {
248                        self.tuna_position_ata_b = Some(tuna_position_ata_b);
249                    self
250    }
251            /// 
252/// Fusion or Orca accounts
253/// 
254#[inline(always)]
255    pub fn pool(&mut self, pool: solana_pubkey::Pubkey) -> &mut Self {
256                        self.pool = Some(pool);
257                    self
258    }
259            /// `[optional account, default to '11111111111111111111111111111111']`
260/// 
261/// Other accounts
262/// 
263#[inline(always)]
264    pub fn system_program(&mut self, system_program: solana_pubkey::Pubkey) -> &mut Self {
265                        self.system_program = Some(system_program);
266                    self
267    }
268            #[inline(always)]
269    pub fn associated_token_program(&mut self, associated_token_program: solana_pubkey::Pubkey) -> &mut Self {
270                        self.associated_token_program = Some(associated_token_program);
271                    self
272    }
273                    #[inline(always)]
274      pub fn position_token(&mut self, position_token: PoolToken) -> &mut Self {
275        self.position_token = Some(position_token);
276        self
277      }
278                #[inline(always)]
279      pub fn collateral_token(&mut self, collateral_token: PoolToken) -> &mut Self {
280        self.collateral_token = Some(collateral_token);
281        self
282      }
283        /// Add an additional account to the instruction.
284  #[inline(always)]
285  pub fn add_remaining_account(&mut self, account: solana_instruction::AccountMeta) -> &mut Self {
286    self.__remaining_accounts.push(account);
287    self
288  }
289  /// Add additional accounts to the instruction.
290  #[inline(always)]
291  pub fn add_remaining_accounts(&mut self, accounts: &[solana_instruction::AccountMeta]) -> &mut Self {
292    self.__remaining_accounts.extend_from_slice(accounts);
293    self
294  }
295  #[allow(clippy::clone_on_copy)]
296  pub fn instruction(&self) -> solana_instruction::Instruction {
297    let accounts = OpenTunaSpotPosition {
298                              authority: self.authority.expect("authority is not set"),
299                                        mint_a: self.mint_a.expect("mint_a is not set"),
300                                        mint_b: self.mint_b.expect("mint_b is not set"),
301                                        token_program_a: self.token_program_a.expect("token_program_a is not set"),
302                                        token_program_b: self.token_program_b.expect("token_program_b is not set"),
303                                        market: self.market.expect("market is not set"),
304                                        tuna_position: self.tuna_position.expect("tuna_position is not set"),
305                                        tuna_position_ata_a: self.tuna_position_ata_a.expect("tuna_position_ata_a is not set"),
306                                        tuna_position_ata_b: self.tuna_position_ata_b.expect("tuna_position_ata_b is not set"),
307                                        pool: self.pool.expect("pool is not set"),
308                                        system_program: self.system_program.unwrap_or(solana_pubkey::pubkey!("11111111111111111111111111111111")),
309                                        associated_token_program: self.associated_token_program.expect("associated_token_program is not set"),
310                      };
311          let args = OpenTunaSpotPositionInstructionArgs {
312                                                              position_token: self.position_token.clone().expect("position_token is not set"),
313                                                                  collateral_token: self.collateral_token.clone().expect("collateral_token is not set"),
314                                    };
315    
316    accounts.instruction_with_remaining_accounts(args, &self.__remaining_accounts)
317  }
318}
319
320  /// `open_tuna_spot_position` CPI accounts.
321  pub struct OpenTunaSpotPositionCpiAccounts<'a, 'b> {
322                  /// 
323/// TUNA accounts
324/// 
325
326      
327                    
328              pub authority: &'b solana_account_info::AccountInfo<'a>,
329                
330                    
331              pub mint_a: &'b solana_account_info::AccountInfo<'a>,
332                
333                    
334              pub mint_b: &'b solana_account_info::AccountInfo<'a>,
335                
336                    
337              pub token_program_a: &'b solana_account_info::AccountInfo<'a>,
338                
339                    
340              pub token_program_b: &'b solana_account_info::AccountInfo<'a>,
341                
342                    
343              pub market: &'b solana_account_info::AccountInfo<'a>,
344                
345                    
346              pub tuna_position: &'b solana_account_info::AccountInfo<'a>,
347                
348                    
349              pub tuna_position_ata_a: &'b solana_account_info::AccountInfo<'a>,
350                
351                    
352              pub tuna_position_ata_b: &'b solana_account_info::AccountInfo<'a>,
353                        /// 
354/// Fusion or Orca accounts
355/// 
356
357      
358                    
359              pub pool: &'b solana_account_info::AccountInfo<'a>,
360                        /// 
361/// Other accounts
362/// 
363
364      
365                    
366              pub system_program: &'b solana_account_info::AccountInfo<'a>,
367                
368                    
369              pub associated_token_program: &'b solana_account_info::AccountInfo<'a>,
370            }
371
372/// `open_tuna_spot_position` CPI instruction.
373pub struct OpenTunaSpotPositionCpi<'a, 'b> {
374  /// The program to invoke.
375  pub __program: &'b solana_account_info::AccountInfo<'a>,
376            /// 
377/// TUNA accounts
378/// 
379
380    
381              
382          pub authority: &'b solana_account_info::AccountInfo<'a>,
383          
384              
385          pub mint_a: &'b solana_account_info::AccountInfo<'a>,
386          
387              
388          pub mint_b: &'b solana_account_info::AccountInfo<'a>,
389          
390              
391          pub token_program_a: &'b solana_account_info::AccountInfo<'a>,
392          
393              
394          pub token_program_b: &'b solana_account_info::AccountInfo<'a>,
395          
396              
397          pub market: &'b solana_account_info::AccountInfo<'a>,
398          
399              
400          pub tuna_position: &'b solana_account_info::AccountInfo<'a>,
401          
402              
403          pub tuna_position_ata_a: &'b solana_account_info::AccountInfo<'a>,
404          
405              
406          pub tuna_position_ata_b: &'b solana_account_info::AccountInfo<'a>,
407                /// 
408/// Fusion or Orca accounts
409/// 
410
411    
412              
413          pub pool: &'b solana_account_info::AccountInfo<'a>,
414                /// 
415/// Other accounts
416/// 
417
418    
419              
420          pub system_program: &'b solana_account_info::AccountInfo<'a>,
421          
422              
423          pub associated_token_program: &'b solana_account_info::AccountInfo<'a>,
424            /// The arguments for the instruction.
425    pub __args: OpenTunaSpotPositionInstructionArgs,
426  }
427
428impl<'a, 'b> OpenTunaSpotPositionCpi<'a, 'b> {
429  pub fn new(
430    program: &'b solana_account_info::AccountInfo<'a>,
431          accounts: OpenTunaSpotPositionCpiAccounts<'a, 'b>,
432              args: OpenTunaSpotPositionInstructionArgs,
433      ) -> Self {
434    Self {
435      __program: program,
436              authority: accounts.authority,
437              mint_a: accounts.mint_a,
438              mint_b: accounts.mint_b,
439              token_program_a: accounts.token_program_a,
440              token_program_b: accounts.token_program_b,
441              market: accounts.market,
442              tuna_position: accounts.tuna_position,
443              tuna_position_ata_a: accounts.tuna_position_ata_a,
444              tuna_position_ata_b: accounts.tuna_position_ata_b,
445              pool: accounts.pool,
446              system_program: accounts.system_program,
447              associated_token_program: accounts.associated_token_program,
448                    __args: args,
449          }
450  }
451  #[inline(always)]
452  pub fn invoke(&self) -> solana_program_error::ProgramResult {
453    self.invoke_signed_with_remaining_accounts(&[], &[])
454  }
455  #[inline(always)]
456  pub fn invoke_with_remaining_accounts(&self, remaining_accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]) -> solana_program_error::ProgramResult {
457    self.invoke_signed_with_remaining_accounts(&[], remaining_accounts)
458  }
459  #[inline(always)]
460  pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program_error::ProgramResult {
461    self.invoke_signed_with_remaining_accounts(signers_seeds, &[])
462  }
463  #[allow(clippy::arithmetic_side_effects)]
464  #[allow(clippy::clone_on_copy)]
465  #[allow(clippy::vec_init_then_push)]
466  pub fn invoke_signed_with_remaining_accounts(
467    &self,
468    signers_seeds: &[&[&[u8]]],
469    remaining_accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]
470  ) -> solana_program_error::ProgramResult {
471    let mut accounts = Vec::with_capacity(12+ remaining_accounts.len());
472                            accounts.push(solana_instruction::AccountMeta::new(
473            *self.authority.key,
474            true
475          ));
476                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
477            *self.mint_a.key,
478            false
479          ));
480                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
481            *self.mint_b.key,
482            false
483          ));
484                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
485            *self.token_program_a.key,
486            false
487          ));
488                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
489            *self.token_program_b.key,
490            false
491          ));
492                                          accounts.push(solana_instruction::AccountMeta::new(
493            *self.market.key,
494            false
495          ));
496                                          accounts.push(solana_instruction::AccountMeta::new(
497            *self.tuna_position.key,
498            false
499          ));
500                                          accounts.push(solana_instruction::AccountMeta::new(
501            *self.tuna_position_ata_a.key,
502            false
503          ));
504                                          accounts.push(solana_instruction::AccountMeta::new(
505            *self.tuna_position_ata_b.key,
506            false
507          ));
508                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
509            *self.pool.key,
510            false
511          ));
512                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
513            *self.system_program.key,
514            false
515          ));
516                                          accounts.push(solana_instruction::AccountMeta::new_readonly(
517            *self.associated_token_program.key,
518            false
519          ));
520                      remaining_accounts.iter().for_each(|remaining_account| {
521      accounts.push(solana_instruction::AccountMeta {
522          pubkey: *remaining_account.0.key,
523          is_signer: remaining_account.1,
524          is_writable: remaining_account.2,
525      })
526    });
527    let mut data = borsh::to_vec(&OpenTunaSpotPositionInstructionData::new()).unwrap();
528          let mut args = borsh::to_vec(&self.__args).unwrap();
529      data.append(&mut args);
530    
531    let instruction = solana_instruction::Instruction {
532      program_id: crate::TUNA_ID,
533      accounts,
534      data,
535    };
536    let mut account_infos = Vec::with_capacity(13 + remaining_accounts.len());
537    account_infos.push(self.__program.clone());
538                  account_infos.push(self.authority.clone());
539                        account_infos.push(self.mint_a.clone());
540                        account_infos.push(self.mint_b.clone());
541                        account_infos.push(self.token_program_a.clone());
542                        account_infos.push(self.token_program_b.clone());
543                        account_infos.push(self.market.clone());
544                        account_infos.push(self.tuna_position.clone());
545                        account_infos.push(self.tuna_position_ata_a.clone());
546                        account_infos.push(self.tuna_position_ata_b.clone());
547                        account_infos.push(self.pool.clone());
548                        account_infos.push(self.system_program.clone());
549                        account_infos.push(self.associated_token_program.clone());
550              remaining_accounts.iter().for_each(|remaining_account| account_infos.push(remaining_account.0.clone()));
551
552    if signers_seeds.is_empty() {
553      solana_cpi::invoke(&instruction, &account_infos)
554    } else {
555      solana_cpi::invoke_signed(&instruction, &account_infos, signers_seeds)
556    }
557  }
558}
559
560/// Instruction builder for `OpenTunaSpotPosition` via CPI.
561///
562/// ### Accounts:
563///
564                      ///   0. `[writable, signer]` authority
565          ///   1. `[]` mint_a
566          ///   2. `[]` mint_b
567          ///   3. `[]` token_program_a
568          ///   4. `[]` token_program_b
569                ///   5. `[writable]` market
570                ///   6. `[writable]` tuna_position
571                ///   7. `[writable]` tuna_position_ata_a
572                ///   8. `[writable]` tuna_position_ata_b
573          ///   9. `[]` pool
574          ///   10. `[]` system_program
575          ///   11. `[]` associated_token_program
576#[derive(Clone, Debug)]
577pub struct OpenTunaSpotPositionCpiBuilder<'a, 'b> {
578  instruction: Box<OpenTunaSpotPositionCpiBuilderInstruction<'a, 'b>>,
579}
580
581impl<'a, 'b> OpenTunaSpotPositionCpiBuilder<'a, 'b> {
582  pub fn new(program: &'b solana_account_info::AccountInfo<'a>) -> Self {
583    let instruction = Box::new(OpenTunaSpotPositionCpiBuilderInstruction {
584      __program: program,
585              authority: None,
586              mint_a: None,
587              mint_b: None,
588              token_program_a: None,
589              token_program_b: None,
590              market: None,
591              tuna_position: None,
592              tuna_position_ata_a: None,
593              tuna_position_ata_b: None,
594              pool: None,
595              system_program: None,
596              associated_token_program: None,
597                                            position_token: None,
598                                collateral_token: None,
599                    __remaining_accounts: Vec::new(),
600    });
601    Self { instruction }
602  }
603      /// 
604/// TUNA accounts
605/// 
606#[inline(always)]
607    pub fn authority(&mut self, authority: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
608                        self.instruction.authority = Some(authority);
609                    self
610    }
611      #[inline(always)]
612    pub fn mint_a(&mut self, mint_a: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
613                        self.instruction.mint_a = Some(mint_a);
614                    self
615    }
616      #[inline(always)]
617    pub fn mint_b(&mut self, mint_b: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
618                        self.instruction.mint_b = Some(mint_b);
619                    self
620    }
621      #[inline(always)]
622    pub fn token_program_a(&mut self, token_program_a: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
623                        self.instruction.token_program_a = Some(token_program_a);
624                    self
625    }
626      #[inline(always)]
627    pub fn token_program_b(&mut self, token_program_b: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
628                        self.instruction.token_program_b = Some(token_program_b);
629                    self
630    }
631      #[inline(always)]
632    pub fn market(&mut self, market: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
633                        self.instruction.market = Some(market);
634                    self
635    }
636      #[inline(always)]
637    pub fn tuna_position(&mut self, tuna_position: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
638                        self.instruction.tuna_position = Some(tuna_position);
639                    self
640    }
641      #[inline(always)]
642    pub fn tuna_position_ata_a(&mut self, tuna_position_ata_a: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
643                        self.instruction.tuna_position_ata_a = Some(tuna_position_ata_a);
644                    self
645    }
646      #[inline(always)]
647    pub fn tuna_position_ata_b(&mut self, tuna_position_ata_b: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
648                        self.instruction.tuna_position_ata_b = Some(tuna_position_ata_b);
649                    self
650    }
651      /// 
652/// Fusion or Orca accounts
653/// 
654#[inline(always)]
655    pub fn pool(&mut self, pool: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
656                        self.instruction.pool = Some(pool);
657                    self
658    }
659      /// 
660/// Other accounts
661/// 
662#[inline(always)]
663    pub fn system_program(&mut self, system_program: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
664                        self.instruction.system_program = Some(system_program);
665                    self
666    }
667      #[inline(always)]
668    pub fn associated_token_program(&mut self, associated_token_program: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
669                        self.instruction.associated_token_program = Some(associated_token_program);
670                    self
671    }
672                    #[inline(always)]
673      pub fn position_token(&mut self, position_token: PoolToken) -> &mut Self {
674        self.instruction.position_token = Some(position_token);
675        self
676      }
677                #[inline(always)]
678      pub fn collateral_token(&mut self, collateral_token: PoolToken) -> &mut Self {
679        self.instruction.collateral_token = Some(collateral_token);
680        self
681      }
682        /// Add an additional account to the instruction.
683  #[inline(always)]
684  pub fn add_remaining_account(&mut self, account: &'b solana_account_info::AccountInfo<'a>, is_writable: bool, is_signer: bool) -> &mut Self {
685    self.instruction.__remaining_accounts.push((account, is_writable, is_signer));
686    self
687  }
688  /// Add additional accounts to the instruction.
689  ///
690  /// Each account is represented by a tuple of the `AccountInfo`, a `bool` indicating whether the account is writable or not,
691  /// and a `bool` indicating whether the account is a signer or not.
692  #[inline(always)]
693  pub fn add_remaining_accounts(&mut self, accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]) -> &mut Self {
694    self.instruction.__remaining_accounts.extend_from_slice(accounts);
695    self
696  }
697  #[inline(always)]
698  pub fn invoke(&self) -> solana_program_error::ProgramResult {
699    self.invoke_signed(&[])
700  }
701  #[allow(clippy::clone_on_copy)]
702  #[allow(clippy::vec_init_then_push)]
703  pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program_error::ProgramResult {
704          let args = OpenTunaSpotPositionInstructionArgs {
705                                                              position_token: self.instruction.position_token.clone().expect("position_token is not set"),
706                                                                  collateral_token: self.instruction.collateral_token.clone().expect("collateral_token is not set"),
707                                    };
708        let instruction = OpenTunaSpotPositionCpi {
709        __program: self.instruction.__program,
710                  
711          authority: self.instruction.authority.expect("authority is not set"),
712                  
713          mint_a: self.instruction.mint_a.expect("mint_a is not set"),
714                  
715          mint_b: self.instruction.mint_b.expect("mint_b is not set"),
716                  
717          token_program_a: self.instruction.token_program_a.expect("token_program_a is not set"),
718                  
719          token_program_b: self.instruction.token_program_b.expect("token_program_b is not set"),
720                  
721          market: self.instruction.market.expect("market is not set"),
722                  
723          tuna_position: self.instruction.tuna_position.expect("tuna_position is not set"),
724                  
725          tuna_position_ata_a: self.instruction.tuna_position_ata_a.expect("tuna_position_ata_a is not set"),
726                  
727          tuna_position_ata_b: self.instruction.tuna_position_ata_b.expect("tuna_position_ata_b is not set"),
728                  
729          pool: self.instruction.pool.expect("pool is not set"),
730                  
731          system_program: self.instruction.system_program.expect("system_program is not set"),
732                  
733          associated_token_program: self.instruction.associated_token_program.expect("associated_token_program is not set"),
734                          __args: args,
735            };
736    instruction.invoke_signed_with_remaining_accounts(signers_seeds, &self.instruction.__remaining_accounts)
737  }
738}
739
740#[derive(Clone, Debug)]
741struct OpenTunaSpotPositionCpiBuilderInstruction<'a, 'b> {
742  __program: &'b solana_account_info::AccountInfo<'a>,
743            authority: Option<&'b solana_account_info::AccountInfo<'a>>,
744                mint_a: Option<&'b solana_account_info::AccountInfo<'a>>,
745                mint_b: Option<&'b solana_account_info::AccountInfo<'a>>,
746                token_program_a: Option<&'b solana_account_info::AccountInfo<'a>>,
747                token_program_b: Option<&'b solana_account_info::AccountInfo<'a>>,
748                market: Option<&'b solana_account_info::AccountInfo<'a>>,
749                tuna_position: Option<&'b solana_account_info::AccountInfo<'a>>,
750                tuna_position_ata_a: Option<&'b solana_account_info::AccountInfo<'a>>,
751                tuna_position_ata_b: Option<&'b solana_account_info::AccountInfo<'a>>,
752                pool: Option<&'b solana_account_info::AccountInfo<'a>>,
753                system_program: Option<&'b solana_account_info::AccountInfo<'a>>,
754                associated_token_program: Option<&'b solana_account_info::AccountInfo<'a>>,
755                        position_token: Option<PoolToken>,
756                collateral_token: Option<PoolToken>,
757        /// Additional instruction accounts `(AccountInfo, is_writable, is_signer)`.
758  __remaining_accounts: Vec<(&'b solana_account_info::AccountInfo<'a>, bool, bool)>,
759}
760
defituna_client/generated/instructions/open_tuna_spot_position.rs

defituna_client/generated/instructions/
open_tuna_spot_position.rs
