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

defituna_client/generated/instructions/
repay_tuna_lp_position_debt.rs
