1use borsh::BorshSerialize;
9use borsh::BorshDeserialize;
10
11pub const MODIFY_TUNA_SPOT_POSITION_JUPITER_DISCRIMINATOR: [u8; 8] = [35, 235, 114, 104, 23, 51, 164, 9];
12
13#[derive(Debug)]
15pub struct ModifyTunaSpotPositionJupiter {
16 pub authority: solana_pubkey::Pubkey,
23
24
25 pub tuna_config: solana_pubkey::Pubkey,
26
27
28 pub mint_a: solana_pubkey::Pubkey,
29
30
31 pub mint_b: solana_pubkey::Pubkey,
32
33
34 pub token_program_a: solana_pubkey::Pubkey,
35
36
37 pub token_program_b: solana_pubkey::Pubkey,
38
39
40 pub market: solana_pubkey::Pubkey,
41
42
43 pub vault_a: solana_pubkey::Pubkey,
44
45
46 pub vault_b: solana_pubkey::Pubkey,
47
48
49 pub vault_a_ata: solana_pubkey::Pubkey,
50
51
52 pub vault_b_ata: solana_pubkey::Pubkey,
53
54
55 pub tuna_position: solana_pubkey::Pubkey,
56
57
58 pub tuna_position_ata_a: solana_pubkey::Pubkey,
59
60
61 pub tuna_position_ata_b: solana_pubkey::Pubkey,
62
63
64 pub tuna_position_owner_ata_a: solana_pubkey::Pubkey,
65
66
67 pub tuna_position_owner_ata_b: solana_pubkey::Pubkey,
68
69
70 pub fee_recipient_ata_a: solana_pubkey::Pubkey,
71
72
73 pub fee_recipient_ata_b: solana_pubkey::Pubkey,
74
75
76 pub pyth_oracle_price_feed_a: solana_pubkey::Pubkey,
77
78
79 pub pyth_oracle_price_feed_b: solana_pubkey::Pubkey,
80
81
82 pub pool: solana_pubkey::Pubkey,
83 pub jupiter_program: solana_pubkey::Pubkey,
90
91
92 pub jupiter_event_authority: solana_pubkey::Pubkey,
93
94
95 pub jupiter_program_authority: solana_pubkey::Pubkey,
96 pub token_program: solana_pubkey::Pubkey,
103
104
105 pub memo_program: solana_pubkey::Pubkey,
106
107
108 pub system_program: solana_pubkey::Pubkey,
109 }
110
111impl ModifyTunaSpotPositionJupiter {
112 pub fn instruction(&self, args: ModifyTunaSpotPositionJupiterInstructionArgs) -> solana_instruction::Instruction {
113 self.instruction_with_remaining_accounts(args, &[])
114 }
115 #[allow(clippy::arithmetic_side_effects)]
116 #[allow(clippy::vec_init_then_push)]
117 pub fn instruction_with_remaining_accounts(&self, args: ModifyTunaSpotPositionJupiterInstructionArgs, remaining_accounts: &[solana_instruction::AccountMeta]) -> solana_instruction::Instruction {
118 let mut accounts = Vec::with_capacity(27+ remaining_accounts.len());
119 accounts.push(solana_instruction::AccountMeta::new(
120 self.authority,
121 true
122 ));
123 accounts.push(solana_instruction::AccountMeta::new_readonly(
124 self.tuna_config,
125 false
126 ));
127 accounts.push(solana_instruction::AccountMeta::new_readonly(
128 self.mint_a,
129 false
130 ));
131 accounts.push(solana_instruction::AccountMeta::new_readonly(
132 self.mint_b,
133 false
134 ));
135 accounts.push(solana_instruction::AccountMeta::new_readonly(
136 self.token_program_a,
137 false
138 ));
139 accounts.push(solana_instruction::AccountMeta::new_readonly(
140 self.token_program_b,
141 false
142 ));
143 accounts.push(solana_instruction::AccountMeta::new(
144 self.market,
145 false
146 ));
147 accounts.push(solana_instruction::AccountMeta::new(
148 self.vault_a,
149 false
150 ));
151 accounts.push(solana_instruction::AccountMeta::new(
152 self.vault_b,
153 false
154 ));
155 accounts.push(solana_instruction::AccountMeta::new(
156 self.vault_a_ata,
157 false
158 ));
159 accounts.push(solana_instruction::AccountMeta::new(
160 self.vault_b_ata,
161 false
162 ));
163 accounts.push(solana_instruction::AccountMeta::new(
164 self.tuna_position,
165 false
166 ));
167 accounts.push(solana_instruction::AccountMeta::new(
168 self.tuna_position_ata_a,
169 false
170 ));
171 accounts.push(solana_instruction::AccountMeta::new(
172 self.tuna_position_ata_b,
173 false
174 ));
175 accounts.push(solana_instruction::AccountMeta::new(
176 self.tuna_position_owner_ata_a,
177 false
178 ));
179 accounts.push(solana_instruction::AccountMeta::new(
180 self.tuna_position_owner_ata_b,
181 false
182 ));
183 accounts.push(solana_instruction::AccountMeta::new(
184 self.fee_recipient_ata_a,
185 false
186 ));
187 accounts.push(solana_instruction::AccountMeta::new(
188 self.fee_recipient_ata_b,
189 false
190 ));
191 accounts.push(solana_instruction::AccountMeta::new_readonly(
192 self.pyth_oracle_price_feed_a,
193 false
194 ));
195 accounts.push(solana_instruction::AccountMeta::new_readonly(
196 self.pyth_oracle_price_feed_b,
197 false
198 ));
199 accounts.push(solana_instruction::AccountMeta::new_readonly(
200 self.pool,
201 false
202 ));
203 accounts.push(solana_instruction::AccountMeta::new_readonly(
204 self.jupiter_program,
205 false
206 ));
207 accounts.push(solana_instruction::AccountMeta::new_readonly(
208 self.jupiter_event_authority,
209 false
210 ));
211 accounts.push(solana_instruction::AccountMeta::new_readonly(
212 self.jupiter_program_authority,
213 false
214 ));
215 accounts.push(solana_instruction::AccountMeta::new_readonly(
216 self.token_program,
217 false
218 ));
219 accounts.push(solana_instruction::AccountMeta::new_readonly(
220 self.memo_program,
221 false
222 ));
223 accounts.push(solana_instruction::AccountMeta::new_readonly(
224 self.system_program,
225 false
226 ));
227 accounts.extend_from_slice(remaining_accounts);
228 let mut data = borsh::to_vec(&ModifyTunaSpotPositionJupiterInstructionData::new()).unwrap();
229 let mut args = borsh::to_vec(&args).unwrap();
230 data.append(&mut args);
231
232 solana_instruction::Instruction {
233 program_id: crate::TUNA_ID,
234 accounts,
235 data,
236 }
237 }
238}
239
240#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
241#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
242 pub struct ModifyTunaSpotPositionJupiterInstructionData {
243 discriminator: [u8; 8],
244 }
245
246impl ModifyTunaSpotPositionJupiterInstructionData {
247 pub fn new() -> Self {
248 Self {
249 discriminator: [35, 235, 114, 104, 23, 51, 164, 9],
250 }
251 }
252}
253
254impl Default for ModifyTunaSpotPositionJupiterInstructionData {
255 fn default() -> Self {
256 Self::new()
257 }
258}
259
260#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
261#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
262 pub struct ModifyTunaSpotPositionJupiterInstructionArgs {
263 pub decrease_percent: u32,
264 pub collateral_amount: u64,
265 pub borrow_amount: u64,
266 pub route_data: Vec<u8>,
267 }
268
269
270#[derive(Clone, Debug, Default)]
302pub struct ModifyTunaSpotPositionJupiterBuilder {
303 authority: Option<solana_pubkey::Pubkey>,
304 tuna_config: Option<solana_pubkey::Pubkey>,
305 mint_a: Option<solana_pubkey::Pubkey>,
306 mint_b: Option<solana_pubkey::Pubkey>,
307 token_program_a: Option<solana_pubkey::Pubkey>,
308 token_program_b: Option<solana_pubkey::Pubkey>,
309 market: Option<solana_pubkey::Pubkey>,
310 vault_a: Option<solana_pubkey::Pubkey>,
311 vault_b: Option<solana_pubkey::Pubkey>,
312 vault_a_ata: Option<solana_pubkey::Pubkey>,
313 vault_b_ata: Option<solana_pubkey::Pubkey>,
314 tuna_position: Option<solana_pubkey::Pubkey>,
315 tuna_position_ata_a: Option<solana_pubkey::Pubkey>,
316 tuna_position_ata_b: Option<solana_pubkey::Pubkey>,
317 tuna_position_owner_ata_a: Option<solana_pubkey::Pubkey>,
318 tuna_position_owner_ata_b: Option<solana_pubkey::Pubkey>,
319 fee_recipient_ata_a: Option<solana_pubkey::Pubkey>,
320 fee_recipient_ata_b: Option<solana_pubkey::Pubkey>,
321 pyth_oracle_price_feed_a: Option<solana_pubkey::Pubkey>,
322 pyth_oracle_price_feed_b: Option<solana_pubkey::Pubkey>,
323 pool: Option<solana_pubkey::Pubkey>,
324 jupiter_program: Option<solana_pubkey::Pubkey>,
325 jupiter_event_authority: Option<solana_pubkey::Pubkey>,
326 jupiter_program_authority: Option<solana_pubkey::Pubkey>,
327 token_program: Option<solana_pubkey::Pubkey>,
328 memo_program: Option<solana_pubkey::Pubkey>,
329 system_program: Option<solana_pubkey::Pubkey>,
330 decrease_percent: Option<u32>,
331 collateral_amount: Option<u64>,
332 borrow_amount: Option<u64>,
333 route_data: Option<Vec<u8>>,
334 __remaining_accounts: Vec<solana_instruction::AccountMeta>,
335}
336
337impl ModifyTunaSpotPositionJupiterBuilder {
338 pub fn new() -> Self {
339 Self::default()
340 }
341 #[inline(always)]
345 pub fn authority(&mut self, authority: solana_pubkey::Pubkey) -> &mut Self {
346 self.authority = Some(authority);
347 self
348 }
349 #[inline(always)]
350 pub fn tuna_config(&mut self, tuna_config: solana_pubkey::Pubkey) -> &mut Self {
351 self.tuna_config = Some(tuna_config);
352 self
353 }
354 #[inline(always)]
355 pub fn mint_a(&mut self, mint_a: solana_pubkey::Pubkey) -> &mut Self {
356 self.mint_a = Some(mint_a);
357 self
358 }
359 #[inline(always)]
360 pub fn mint_b(&mut self, mint_b: solana_pubkey::Pubkey) -> &mut Self {
361 self.mint_b = Some(mint_b);
362 self
363 }
364 #[inline(always)]
365 pub fn token_program_a(&mut self, token_program_a: solana_pubkey::Pubkey) -> &mut Self {
366 self.token_program_a = Some(token_program_a);
367 self
368 }
369 #[inline(always)]
370 pub fn token_program_b(&mut self, token_program_b: solana_pubkey::Pubkey) -> &mut Self {
371 self.token_program_b = Some(token_program_b);
372 self
373 }
374 #[inline(always)]
375 pub fn market(&mut self, market: solana_pubkey::Pubkey) -> &mut Self {
376 self.market = Some(market);
377 self
378 }
379 #[inline(always)]
380 pub fn vault_a(&mut self, vault_a: solana_pubkey::Pubkey) -> &mut Self {
381 self.vault_a = Some(vault_a);
382 self
383 }
384 #[inline(always)]
385 pub fn vault_b(&mut self, vault_b: solana_pubkey::Pubkey) -> &mut Self {
386 self.vault_b = Some(vault_b);
387 self
388 }
389 #[inline(always)]
390 pub fn vault_a_ata(&mut self, vault_a_ata: solana_pubkey::Pubkey) -> &mut Self {
391 self.vault_a_ata = Some(vault_a_ata);
392 self
393 }
394 #[inline(always)]
395 pub fn vault_b_ata(&mut self, vault_b_ata: solana_pubkey::Pubkey) -> &mut Self {
396 self.vault_b_ata = Some(vault_b_ata);
397 self
398 }
399 #[inline(always)]
400 pub fn tuna_position(&mut self, tuna_position: solana_pubkey::Pubkey) -> &mut Self {
401 self.tuna_position = Some(tuna_position);
402 self
403 }
404 #[inline(always)]
405 pub fn tuna_position_ata_a(&mut self, tuna_position_ata_a: solana_pubkey::Pubkey) -> &mut Self {
406 self.tuna_position_ata_a = Some(tuna_position_ata_a);
407 self
408 }
409 #[inline(always)]
410 pub fn tuna_position_ata_b(&mut self, tuna_position_ata_b: solana_pubkey::Pubkey) -> &mut Self {
411 self.tuna_position_ata_b = Some(tuna_position_ata_b);
412 self
413 }
414 #[inline(always)]
415 pub fn tuna_position_owner_ata_a(&mut self, tuna_position_owner_ata_a: solana_pubkey::Pubkey) -> &mut Self {
416 self.tuna_position_owner_ata_a = Some(tuna_position_owner_ata_a);
417 self
418 }
419 #[inline(always)]
420 pub fn tuna_position_owner_ata_b(&mut self, tuna_position_owner_ata_b: solana_pubkey::Pubkey) -> &mut Self {
421 self.tuna_position_owner_ata_b = Some(tuna_position_owner_ata_b);
422 self
423 }
424 #[inline(always)]
425 pub fn fee_recipient_ata_a(&mut self, fee_recipient_ata_a: solana_pubkey::Pubkey) -> &mut Self {
426 self.fee_recipient_ata_a = Some(fee_recipient_ata_a);
427 self
428 }
429 #[inline(always)]
430 pub fn fee_recipient_ata_b(&mut self, fee_recipient_ata_b: solana_pubkey::Pubkey) -> &mut Self {
431 self.fee_recipient_ata_b = Some(fee_recipient_ata_b);
432 self
433 }
434 #[inline(always)]
435 pub fn pyth_oracle_price_feed_a(&mut self, pyth_oracle_price_feed_a: solana_pubkey::Pubkey) -> &mut Self {
436 self.pyth_oracle_price_feed_a = Some(pyth_oracle_price_feed_a);
437 self
438 }
439 #[inline(always)]
440 pub fn pyth_oracle_price_feed_b(&mut self, pyth_oracle_price_feed_b: solana_pubkey::Pubkey) -> &mut Self {
441 self.pyth_oracle_price_feed_b = Some(pyth_oracle_price_feed_b);
442 self
443 }
444 #[inline(always)]
445 pub fn pool(&mut self, pool: solana_pubkey::Pubkey) -> &mut Self {
446 self.pool = Some(pool);
447 self
448 }
449 #[inline(always)]
453 pub fn jupiter_program(&mut self, jupiter_program: solana_pubkey::Pubkey) -> &mut Self {
454 self.jupiter_program = Some(jupiter_program);
455 self
456 }
457 #[inline(always)]
458 pub fn jupiter_event_authority(&mut self, jupiter_event_authority: solana_pubkey::Pubkey) -> &mut Self {
459 self.jupiter_event_authority = Some(jupiter_event_authority);
460 self
461 }
462 #[inline(always)]
463 pub fn jupiter_program_authority(&mut self, jupiter_program_authority: solana_pubkey::Pubkey) -> &mut Self {
464 self.jupiter_program_authority = Some(jupiter_program_authority);
465 self
466 }
467 #[inline(always)]
472 pub fn token_program(&mut self, token_program: solana_pubkey::Pubkey) -> &mut Self {
473 self.token_program = Some(token_program);
474 self
475 }
476 #[inline(always)]
477 pub fn memo_program(&mut self, memo_program: solana_pubkey::Pubkey) -> &mut Self {
478 self.memo_program = Some(memo_program);
479 self
480 }
481 #[inline(always)]
483 pub fn system_program(&mut self, system_program: solana_pubkey::Pubkey) -> &mut Self {
484 self.system_program = Some(system_program);
485 self
486 }
487 #[inline(always)]
488 pub fn decrease_percent(&mut self, decrease_percent: u32) -> &mut Self {
489 self.decrease_percent = Some(decrease_percent);
490 self
491 }
492 #[inline(always)]
493 pub fn collateral_amount(&mut self, collateral_amount: u64) -> &mut Self {
494 self.collateral_amount = Some(collateral_amount);
495 self
496 }
497 #[inline(always)]
498 pub fn borrow_amount(&mut self, borrow_amount: u64) -> &mut Self {
499 self.borrow_amount = Some(borrow_amount);
500 self
501 }
502 #[inline(always)]
503 pub fn route_data(&mut self, route_data: Vec<u8>) -> &mut Self {
504 self.route_data = Some(route_data);
505 self
506 }
507 #[inline(always)]
509 pub fn add_remaining_account(&mut self, account: solana_instruction::AccountMeta) -> &mut Self {
510 self.__remaining_accounts.push(account);
511 self
512 }
513 #[inline(always)]
515 pub fn add_remaining_accounts(&mut self, accounts: &[solana_instruction::AccountMeta]) -> &mut Self {
516 self.__remaining_accounts.extend_from_slice(accounts);
517 self
518 }
519 #[allow(clippy::clone_on_copy)]
520 pub fn instruction(&self) -> solana_instruction::Instruction {
521 let accounts = ModifyTunaSpotPositionJupiter {
522 authority: self.authority.expect("authority is not set"),
523 tuna_config: self.tuna_config.expect("tuna_config is not set"),
524 mint_a: self.mint_a.expect("mint_a is not set"),
525 mint_b: self.mint_b.expect("mint_b is not set"),
526 token_program_a: self.token_program_a.expect("token_program_a is not set"),
527 token_program_b: self.token_program_b.expect("token_program_b is not set"),
528 market: self.market.expect("market is not set"),
529 vault_a: self.vault_a.expect("vault_a is not set"),
530 vault_b: self.vault_b.expect("vault_b is not set"),
531 vault_a_ata: self.vault_a_ata.expect("vault_a_ata is not set"),
532 vault_b_ata: self.vault_b_ata.expect("vault_b_ata is not set"),
533 tuna_position: self.tuna_position.expect("tuna_position is not set"),
534 tuna_position_ata_a: self.tuna_position_ata_a.expect("tuna_position_ata_a is not set"),
535 tuna_position_ata_b: self.tuna_position_ata_b.expect("tuna_position_ata_b is not set"),
536 tuna_position_owner_ata_a: self.tuna_position_owner_ata_a.expect("tuna_position_owner_ata_a is not set"),
537 tuna_position_owner_ata_b: self.tuna_position_owner_ata_b.expect("tuna_position_owner_ata_b is not set"),
538 fee_recipient_ata_a: self.fee_recipient_ata_a.expect("fee_recipient_ata_a is not set"),
539 fee_recipient_ata_b: self.fee_recipient_ata_b.expect("fee_recipient_ata_b is not set"),
540 pyth_oracle_price_feed_a: self.pyth_oracle_price_feed_a.expect("pyth_oracle_price_feed_a is not set"),
541 pyth_oracle_price_feed_b: self.pyth_oracle_price_feed_b.expect("pyth_oracle_price_feed_b is not set"),
542 pool: self.pool.expect("pool is not set"),
543 jupiter_program: self.jupiter_program.expect("jupiter_program is not set"),
544 jupiter_event_authority: self.jupiter_event_authority.expect("jupiter_event_authority is not set"),
545 jupiter_program_authority: self.jupiter_program_authority.expect("jupiter_program_authority is not set"),
546 token_program: self.token_program.unwrap_or(solana_pubkey::pubkey!("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")),
547 memo_program: self.memo_program.expect("memo_program is not set"),
548 system_program: self.system_program.unwrap_or(solana_pubkey::pubkey!("11111111111111111111111111111111")),
549 };
550 let args = ModifyTunaSpotPositionJupiterInstructionArgs {
551 decrease_percent: self.decrease_percent.clone().expect("decrease_percent is not set"),
552 collateral_amount: self.collateral_amount.clone().expect("collateral_amount is not set"),
553 borrow_amount: self.borrow_amount.clone().expect("borrow_amount is not set"),
554 route_data: self.route_data.clone().expect("route_data is not set"),
555 };
556
557 accounts.instruction_with_remaining_accounts(args, &self.__remaining_accounts)
558 }
559}
560
561 pub struct ModifyTunaSpotPositionJupiterCpiAccounts<'a, 'b> {
563 pub authority: &'b solana_account_info::AccountInfo<'a>,
570
571
572 pub tuna_config: &'b solana_account_info::AccountInfo<'a>,
573
574
575 pub mint_a: &'b solana_account_info::AccountInfo<'a>,
576
577
578 pub mint_b: &'b solana_account_info::AccountInfo<'a>,
579
580
581 pub token_program_a: &'b solana_account_info::AccountInfo<'a>,
582
583
584 pub token_program_b: &'b solana_account_info::AccountInfo<'a>,
585
586
587 pub market: &'b solana_account_info::AccountInfo<'a>,
588
589
590 pub vault_a: &'b solana_account_info::AccountInfo<'a>,
591
592
593 pub vault_b: &'b solana_account_info::AccountInfo<'a>,
594
595
596 pub vault_a_ata: &'b solana_account_info::AccountInfo<'a>,
597
598
599 pub vault_b_ata: &'b solana_account_info::AccountInfo<'a>,
600
601
602 pub tuna_position: &'b solana_account_info::AccountInfo<'a>,
603
604
605 pub tuna_position_ata_a: &'b solana_account_info::AccountInfo<'a>,
606
607
608 pub tuna_position_ata_b: &'b solana_account_info::AccountInfo<'a>,
609
610
611 pub tuna_position_owner_ata_a: &'b solana_account_info::AccountInfo<'a>,
612
613
614 pub tuna_position_owner_ata_b: &'b solana_account_info::AccountInfo<'a>,
615
616
617 pub fee_recipient_ata_a: &'b solana_account_info::AccountInfo<'a>,
618
619
620 pub fee_recipient_ata_b: &'b solana_account_info::AccountInfo<'a>,
621
622
623 pub pyth_oracle_price_feed_a: &'b solana_account_info::AccountInfo<'a>,
624
625
626 pub pyth_oracle_price_feed_b: &'b solana_account_info::AccountInfo<'a>,
627
628
629 pub pool: &'b solana_account_info::AccountInfo<'a>,
630 pub jupiter_program: &'b solana_account_info::AccountInfo<'a>,
637
638
639 pub jupiter_event_authority: &'b solana_account_info::AccountInfo<'a>,
640
641
642 pub jupiter_program_authority: &'b solana_account_info::AccountInfo<'a>,
643 pub token_program: &'b solana_account_info::AccountInfo<'a>,
650
651
652 pub memo_program: &'b solana_account_info::AccountInfo<'a>,
653
654
655 pub system_program: &'b solana_account_info::AccountInfo<'a>,
656 }
657
658pub struct ModifyTunaSpotPositionJupiterCpi<'a, 'b> {
660 pub __program: &'b solana_account_info::AccountInfo<'a>,
662 pub authority: &'b solana_account_info::AccountInfo<'a>,
669
670
671 pub tuna_config: &'b solana_account_info::AccountInfo<'a>,
672
673
674 pub mint_a: &'b solana_account_info::AccountInfo<'a>,
675
676
677 pub mint_b: &'b solana_account_info::AccountInfo<'a>,
678
679
680 pub token_program_a: &'b solana_account_info::AccountInfo<'a>,
681
682
683 pub token_program_b: &'b solana_account_info::AccountInfo<'a>,
684
685
686 pub market: &'b solana_account_info::AccountInfo<'a>,
687
688
689 pub vault_a: &'b solana_account_info::AccountInfo<'a>,
690
691
692 pub vault_b: &'b solana_account_info::AccountInfo<'a>,
693
694
695 pub vault_a_ata: &'b solana_account_info::AccountInfo<'a>,
696
697
698 pub vault_b_ata: &'b solana_account_info::AccountInfo<'a>,
699
700
701 pub tuna_position: &'b solana_account_info::AccountInfo<'a>,
702
703
704 pub tuna_position_ata_a: &'b solana_account_info::AccountInfo<'a>,
705
706
707 pub tuna_position_ata_b: &'b solana_account_info::AccountInfo<'a>,
708
709
710 pub tuna_position_owner_ata_a: &'b solana_account_info::AccountInfo<'a>,
711
712
713 pub tuna_position_owner_ata_b: &'b solana_account_info::AccountInfo<'a>,
714
715
716 pub fee_recipient_ata_a: &'b solana_account_info::AccountInfo<'a>,
717
718
719 pub fee_recipient_ata_b: &'b solana_account_info::AccountInfo<'a>,
720
721
722 pub pyth_oracle_price_feed_a: &'b solana_account_info::AccountInfo<'a>,
723
724
725 pub pyth_oracle_price_feed_b: &'b solana_account_info::AccountInfo<'a>,
726
727
728 pub pool: &'b solana_account_info::AccountInfo<'a>,
729 pub jupiter_program: &'b solana_account_info::AccountInfo<'a>,
736
737
738 pub jupiter_event_authority: &'b solana_account_info::AccountInfo<'a>,
739
740
741 pub jupiter_program_authority: &'b solana_account_info::AccountInfo<'a>,
742 pub token_program: &'b solana_account_info::AccountInfo<'a>,
749
750
751 pub memo_program: &'b solana_account_info::AccountInfo<'a>,
752
753
754 pub system_program: &'b solana_account_info::AccountInfo<'a>,
755 pub __args: ModifyTunaSpotPositionJupiterInstructionArgs,
757 }
758
759impl<'a, 'b> ModifyTunaSpotPositionJupiterCpi<'a, 'b> {
760 pub fn new(
761 program: &'b solana_account_info::AccountInfo<'a>,
762 accounts: ModifyTunaSpotPositionJupiterCpiAccounts<'a, 'b>,
763 args: ModifyTunaSpotPositionJupiterInstructionArgs,
764 ) -> Self {
765 Self {
766 __program: program,
767 authority: accounts.authority,
768 tuna_config: accounts.tuna_config,
769 mint_a: accounts.mint_a,
770 mint_b: accounts.mint_b,
771 token_program_a: accounts.token_program_a,
772 token_program_b: accounts.token_program_b,
773 market: accounts.market,
774 vault_a: accounts.vault_a,
775 vault_b: accounts.vault_b,
776 vault_a_ata: accounts.vault_a_ata,
777 vault_b_ata: accounts.vault_b_ata,
778 tuna_position: accounts.tuna_position,
779 tuna_position_ata_a: accounts.tuna_position_ata_a,
780 tuna_position_ata_b: accounts.tuna_position_ata_b,
781 tuna_position_owner_ata_a: accounts.tuna_position_owner_ata_a,
782 tuna_position_owner_ata_b: accounts.tuna_position_owner_ata_b,
783 fee_recipient_ata_a: accounts.fee_recipient_ata_a,
784 fee_recipient_ata_b: accounts.fee_recipient_ata_b,
785 pyth_oracle_price_feed_a: accounts.pyth_oracle_price_feed_a,
786 pyth_oracle_price_feed_b: accounts.pyth_oracle_price_feed_b,
787 pool: accounts.pool,
788 jupiter_program: accounts.jupiter_program,
789 jupiter_event_authority: accounts.jupiter_event_authority,
790 jupiter_program_authority: accounts.jupiter_program_authority,
791 token_program: accounts.token_program,
792 memo_program: accounts.memo_program,
793 system_program: accounts.system_program,
794 __args: args,
795 }
796 }
797 #[inline(always)]
798 pub fn invoke(&self) -> solana_program_error::ProgramResult {
799 self.invoke_signed_with_remaining_accounts(&[], &[])
800 }
801 #[inline(always)]
802 pub fn invoke_with_remaining_accounts(&self, remaining_accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]) -> solana_program_error::ProgramResult {
803 self.invoke_signed_with_remaining_accounts(&[], remaining_accounts)
804 }
805 #[inline(always)]
806 pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program_error::ProgramResult {
807 self.invoke_signed_with_remaining_accounts(signers_seeds, &[])
808 }
809 #[allow(clippy::arithmetic_side_effects)]
810 #[allow(clippy::clone_on_copy)]
811 #[allow(clippy::vec_init_then_push)]
812 pub fn invoke_signed_with_remaining_accounts(
813 &self,
814 signers_seeds: &[&[&[u8]]],
815 remaining_accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]
816 ) -> solana_program_error::ProgramResult {
817 let mut accounts = Vec::with_capacity(27+ remaining_accounts.len());
818 accounts.push(solana_instruction::AccountMeta::new(
819 *self.authority.key,
820 true
821 ));
822 accounts.push(solana_instruction::AccountMeta::new_readonly(
823 *self.tuna_config.key,
824 false
825 ));
826 accounts.push(solana_instruction::AccountMeta::new_readonly(
827 *self.mint_a.key,
828 false
829 ));
830 accounts.push(solana_instruction::AccountMeta::new_readonly(
831 *self.mint_b.key,
832 false
833 ));
834 accounts.push(solana_instruction::AccountMeta::new_readonly(
835 *self.token_program_a.key,
836 false
837 ));
838 accounts.push(solana_instruction::AccountMeta::new_readonly(
839 *self.token_program_b.key,
840 false
841 ));
842 accounts.push(solana_instruction::AccountMeta::new(
843 *self.market.key,
844 false
845 ));
846 accounts.push(solana_instruction::AccountMeta::new(
847 *self.vault_a.key,
848 false
849 ));
850 accounts.push(solana_instruction::AccountMeta::new(
851 *self.vault_b.key,
852 false
853 ));
854 accounts.push(solana_instruction::AccountMeta::new(
855 *self.vault_a_ata.key,
856 false
857 ));
858 accounts.push(solana_instruction::AccountMeta::new(
859 *self.vault_b_ata.key,
860 false
861 ));
862 accounts.push(solana_instruction::AccountMeta::new(
863 *self.tuna_position.key,
864 false
865 ));
866 accounts.push(solana_instruction::AccountMeta::new(
867 *self.tuna_position_ata_a.key,
868 false
869 ));
870 accounts.push(solana_instruction::AccountMeta::new(
871 *self.tuna_position_ata_b.key,
872 false
873 ));
874 accounts.push(solana_instruction::AccountMeta::new(
875 *self.tuna_position_owner_ata_a.key,
876 false
877 ));
878 accounts.push(solana_instruction::AccountMeta::new(
879 *self.tuna_position_owner_ata_b.key,
880 false
881 ));
882 accounts.push(solana_instruction::AccountMeta::new(
883 *self.fee_recipient_ata_a.key,
884 false
885 ));
886 accounts.push(solana_instruction::AccountMeta::new(
887 *self.fee_recipient_ata_b.key,
888 false
889 ));
890 accounts.push(solana_instruction::AccountMeta::new_readonly(
891 *self.pyth_oracle_price_feed_a.key,
892 false
893 ));
894 accounts.push(solana_instruction::AccountMeta::new_readonly(
895 *self.pyth_oracle_price_feed_b.key,
896 false
897 ));
898 accounts.push(solana_instruction::AccountMeta::new_readonly(
899 *self.pool.key,
900 false
901 ));
902 accounts.push(solana_instruction::AccountMeta::new_readonly(
903 *self.jupiter_program.key,
904 false
905 ));
906 accounts.push(solana_instruction::AccountMeta::new_readonly(
907 *self.jupiter_event_authority.key,
908 false
909 ));
910 accounts.push(solana_instruction::AccountMeta::new_readonly(
911 *self.jupiter_program_authority.key,
912 false
913 ));
914 accounts.push(solana_instruction::AccountMeta::new_readonly(
915 *self.token_program.key,
916 false
917 ));
918 accounts.push(solana_instruction::AccountMeta::new_readonly(
919 *self.memo_program.key,
920 false
921 ));
922 accounts.push(solana_instruction::AccountMeta::new_readonly(
923 *self.system_program.key,
924 false
925 ));
926 remaining_accounts.iter().for_each(|remaining_account| {
927 accounts.push(solana_instruction::AccountMeta {
928 pubkey: *remaining_account.0.key,
929 is_signer: remaining_account.1,
930 is_writable: remaining_account.2,
931 })
932 });
933 let mut data = borsh::to_vec(&ModifyTunaSpotPositionJupiterInstructionData::new()).unwrap();
934 let mut args = borsh::to_vec(&self.__args).unwrap();
935 data.append(&mut args);
936
937 let instruction = solana_instruction::Instruction {
938 program_id: crate::TUNA_ID,
939 accounts,
940 data,
941 };
942 let mut account_infos = Vec::with_capacity(28 + remaining_accounts.len());
943 account_infos.push(self.__program.clone());
944 account_infos.push(self.authority.clone());
945 account_infos.push(self.tuna_config.clone());
946 account_infos.push(self.mint_a.clone());
947 account_infos.push(self.mint_b.clone());
948 account_infos.push(self.token_program_a.clone());
949 account_infos.push(self.token_program_b.clone());
950 account_infos.push(self.market.clone());
951 account_infos.push(self.vault_a.clone());
952 account_infos.push(self.vault_b.clone());
953 account_infos.push(self.vault_a_ata.clone());
954 account_infos.push(self.vault_b_ata.clone());
955 account_infos.push(self.tuna_position.clone());
956 account_infos.push(self.tuna_position_ata_a.clone());
957 account_infos.push(self.tuna_position_ata_b.clone());
958 account_infos.push(self.tuna_position_owner_ata_a.clone());
959 account_infos.push(self.tuna_position_owner_ata_b.clone());
960 account_infos.push(self.fee_recipient_ata_a.clone());
961 account_infos.push(self.fee_recipient_ata_b.clone());
962 account_infos.push(self.pyth_oracle_price_feed_a.clone());
963 account_infos.push(self.pyth_oracle_price_feed_b.clone());
964 account_infos.push(self.pool.clone());
965 account_infos.push(self.jupiter_program.clone());
966 account_infos.push(self.jupiter_event_authority.clone());
967 account_infos.push(self.jupiter_program_authority.clone());
968 account_infos.push(self.token_program.clone());
969 account_infos.push(self.memo_program.clone());
970 account_infos.push(self.system_program.clone());
971 remaining_accounts.iter().for_each(|remaining_account| account_infos.push(remaining_account.0.clone()));
972
973 if signers_seeds.is_empty() {
974 solana_cpi::invoke(&instruction, &account_infos)
975 } else {
976 solana_cpi::invoke_signed(&instruction, &account_infos, signers_seeds)
977 }
978 }
979}
980
981#[derive(Clone, Debug)]
1013pub struct ModifyTunaSpotPositionJupiterCpiBuilder<'a, 'b> {
1014 instruction: Box<ModifyTunaSpotPositionJupiterCpiBuilderInstruction<'a, 'b>>,
1015}
1016
1017impl<'a, 'b> ModifyTunaSpotPositionJupiterCpiBuilder<'a, 'b> {
1018 pub fn new(program: &'b solana_account_info::AccountInfo<'a>) -> Self {
1019 let instruction = Box::new(ModifyTunaSpotPositionJupiterCpiBuilderInstruction {
1020 __program: program,
1021 authority: None,
1022 tuna_config: None,
1023 mint_a: None,
1024 mint_b: None,
1025 token_program_a: None,
1026 token_program_b: None,
1027 market: None,
1028 vault_a: None,
1029 vault_b: None,
1030 vault_a_ata: None,
1031 vault_b_ata: None,
1032 tuna_position: None,
1033 tuna_position_ata_a: None,
1034 tuna_position_ata_b: None,
1035 tuna_position_owner_ata_a: None,
1036 tuna_position_owner_ata_b: None,
1037 fee_recipient_ata_a: None,
1038 fee_recipient_ata_b: None,
1039 pyth_oracle_price_feed_a: None,
1040 pyth_oracle_price_feed_b: None,
1041 pool: None,
1042 jupiter_program: None,
1043 jupiter_event_authority: None,
1044 jupiter_program_authority: None,
1045 token_program: None,
1046 memo_program: None,
1047 system_program: None,
1048 decrease_percent: None,
1049 collateral_amount: None,
1050 borrow_amount: None,
1051 route_data: None,
1052 __remaining_accounts: Vec::new(),
1053 });
1054 Self { instruction }
1055 }
1056 #[inline(always)]
1060 pub fn authority(&mut self, authority: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1061 self.instruction.authority = Some(authority);
1062 self
1063 }
1064 #[inline(always)]
1065 pub fn tuna_config(&mut self, tuna_config: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1066 self.instruction.tuna_config = Some(tuna_config);
1067 self
1068 }
1069 #[inline(always)]
1070 pub fn mint_a(&mut self, mint_a: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1071 self.instruction.mint_a = Some(mint_a);
1072 self
1073 }
1074 #[inline(always)]
1075 pub fn mint_b(&mut self, mint_b: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1076 self.instruction.mint_b = Some(mint_b);
1077 self
1078 }
1079 #[inline(always)]
1080 pub fn token_program_a(&mut self, token_program_a: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1081 self.instruction.token_program_a = Some(token_program_a);
1082 self
1083 }
1084 #[inline(always)]
1085 pub fn token_program_b(&mut self, token_program_b: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1086 self.instruction.token_program_b = Some(token_program_b);
1087 self
1088 }
1089 #[inline(always)]
1090 pub fn market(&mut self, market: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1091 self.instruction.market = Some(market);
1092 self
1093 }
1094 #[inline(always)]
1095 pub fn vault_a(&mut self, vault_a: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1096 self.instruction.vault_a = Some(vault_a);
1097 self
1098 }
1099 #[inline(always)]
1100 pub fn vault_b(&mut self, vault_b: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1101 self.instruction.vault_b = Some(vault_b);
1102 self
1103 }
1104 #[inline(always)]
1105 pub fn vault_a_ata(&mut self, vault_a_ata: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1106 self.instruction.vault_a_ata = Some(vault_a_ata);
1107 self
1108 }
1109 #[inline(always)]
1110 pub fn vault_b_ata(&mut self, vault_b_ata: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1111 self.instruction.vault_b_ata = Some(vault_b_ata);
1112 self
1113 }
1114 #[inline(always)]
1115 pub fn tuna_position(&mut self, tuna_position: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1116 self.instruction.tuna_position = Some(tuna_position);
1117 self
1118 }
1119 #[inline(always)]
1120 pub fn tuna_position_ata_a(&mut self, tuna_position_ata_a: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1121 self.instruction.tuna_position_ata_a = Some(tuna_position_ata_a);
1122 self
1123 }
1124 #[inline(always)]
1125 pub fn tuna_position_ata_b(&mut self, tuna_position_ata_b: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1126 self.instruction.tuna_position_ata_b = Some(tuna_position_ata_b);
1127 self
1128 }
1129 #[inline(always)]
1130 pub fn tuna_position_owner_ata_a(&mut self, tuna_position_owner_ata_a: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1131 self.instruction.tuna_position_owner_ata_a = Some(tuna_position_owner_ata_a);
1132 self
1133 }
1134 #[inline(always)]
1135 pub fn tuna_position_owner_ata_b(&mut self, tuna_position_owner_ata_b: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1136 self.instruction.tuna_position_owner_ata_b = Some(tuna_position_owner_ata_b);
1137 self
1138 }
1139 #[inline(always)]
1140 pub fn fee_recipient_ata_a(&mut self, fee_recipient_ata_a: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1141 self.instruction.fee_recipient_ata_a = Some(fee_recipient_ata_a);
1142 self
1143 }
1144 #[inline(always)]
1145 pub fn fee_recipient_ata_b(&mut self, fee_recipient_ata_b: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1146 self.instruction.fee_recipient_ata_b = Some(fee_recipient_ata_b);
1147 self
1148 }
1149 #[inline(always)]
1150 pub fn pyth_oracle_price_feed_a(&mut self, pyth_oracle_price_feed_a: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1151 self.instruction.pyth_oracle_price_feed_a = Some(pyth_oracle_price_feed_a);
1152 self
1153 }
1154 #[inline(always)]
1155 pub fn pyth_oracle_price_feed_b(&mut self, pyth_oracle_price_feed_b: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1156 self.instruction.pyth_oracle_price_feed_b = Some(pyth_oracle_price_feed_b);
1157 self
1158 }
1159 #[inline(always)]
1160 pub fn pool(&mut self, pool: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1161 self.instruction.pool = Some(pool);
1162 self
1163 }
1164 #[inline(always)]
1168 pub fn jupiter_program(&mut self, jupiter_program: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1169 self.instruction.jupiter_program = Some(jupiter_program);
1170 self
1171 }
1172 #[inline(always)]
1173 pub fn jupiter_event_authority(&mut self, jupiter_event_authority: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1174 self.instruction.jupiter_event_authority = Some(jupiter_event_authority);
1175 self
1176 }
1177 #[inline(always)]
1178 pub fn jupiter_program_authority(&mut self, jupiter_program_authority: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1179 self.instruction.jupiter_program_authority = Some(jupiter_program_authority);
1180 self
1181 }
1182 #[inline(always)]
1186 pub fn token_program(&mut self, token_program: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1187 self.instruction.token_program = Some(token_program);
1188 self
1189 }
1190 #[inline(always)]
1191 pub fn memo_program(&mut self, memo_program: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1192 self.instruction.memo_program = Some(memo_program);
1193 self
1194 }
1195 #[inline(always)]
1196 pub fn system_program(&mut self, system_program: &'b solana_account_info::AccountInfo<'a>) -> &mut Self {
1197 self.instruction.system_program = Some(system_program);
1198 self
1199 }
1200 #[inline(always)]
1201 pub fn decrease_percent(&mut self, decrease_percent: u32) -> &mut Self {
1202 self.instruction.decrease_percent = Some(decrease_percent);
1203 self
1204 }
1205 #[inline(always)]
1206 pub fn collateral_amount(&mut self, collateral_amount: u64) -> &mut Self {
1207 self.instruction.collateral_amount = Some(collateral_amount);
1208 self
1209 }
1210 #[inline(always)]
1211 pub fn borrow_amount(&mut self, borrow_amount: u64) -> &mut Self {
1212 self.instruction.borrow_amount = Some(borrow_amount);
1213 self
1214 }
1215 #[inline(always)]
1216 pub fn route_data(&mut self, route_data: Vec<u8>) -> &mut Self {
1217 self.instruction.route_data = Some(route_data);
1218 self
1219 }
1220 #[inline(always)]
1222 pub fn add_remaining_account(&mut self, account: &'b solana_account_info::AccountInfo<'a>, is_writable: bool, is_signer: bool) -> &mut Self {
1223 self.instruction.__remaining_accounts.push((account, is_writable, is_signer));
1224 self
1225 }
1226 #[inline(always)]
1231 pub fn add_remaining_accounts(&mut self, accounts: &[(&'b solana_account_info::AccountInfo<'a>, bool, bool)]) -> &mut Self {
1232 self.instruction.__remaining_accounts.extend_from_slice(accounts);
1233 self
1234 }
1235 #[inline(always)]
1236 pub fn invoke(&self) -> solana_program_error::ProgramResult {
1237 self.invoke_signed(&[])
1238 }
1239 #[allow(clippy::clone_on_copy)]
1240 #[allow(clippy::vec_init_then_push)]
1241 pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program_error::ProgramResult {
1242 let args = ModifyTunaSpotPositionJupiterInstructionArgs {
1243 decrease_percent: self.instruction.decrease_percent.clone().expect("decrease_percent is not set"),
1244 collateral_amount: self.instruction.collateral_amount.clone().expect("collateral_amount is not set"),
1245 borrow_amount: self.instruction.borrow_amount.clone().expect("borrow_amount is not set"),
1246 route_data: self.instruction.route_data.clone().expect("route_data is not set"),
1247 };
1248 let instruction = ModifyTunaSpotPositionJupiterCpi {
1249 __program: self.instruction.__program,
1250
1251 authority: self.instruction.authority.expect("authority is not set"),
1252
1253 tuna_config: self.instruction.tuna_config.expect("tuna_config is not set"),
1254
1255 mint_a: self.instruction.mint_a.expect("mint_a is not set"),
1256
1257 mint_b: self.instruction.mint_b.expect("mint_b is not set"),
1258
1259 token_program_a: self.instruction.token_program_a.expect("token_program_a is not set"),
1260
1261 token_program_b: self.instruction.token_program_b.expect("token_program_b is not set"),
1262
1263 market: self.instruction.market.expect("market is not set"),
1264
1265 vault_a: self.instruction.vault_a.expect("vault_a is not set"),
1266
1267 vault_b: self.instruction.vault_b.expect("vault_b is not set"),
1268
1269 vault_a_ata: self.instruction.vault_a_ata.expect("vault_a_ata is not set"),
1270
1271 vault_b_ata: self.instruction.vault_b_ata.expect("vault_b_ata is not set"),
1272
1273 tuna_position: self.instruction.tuna_position.expect("tuna_position is not set"),
1274
1275 tuna_position_ata_a: self.instruction.tuna_position_ata_a.expect("tuna_position_ata_a is not set"),
1276
1277 tuna_position_ata_b: self.instruction.tuna_position_ata_b.expect("tuna_position_ata_b is not set"),
1278
1279 tuna_position_owner_ata_a: self.instruction.tuna_position_owner_ata_a.expect("tuna_position_owner_ata_a is not set"),
1280
1281 tuna_position_owner_ata_b: self.instruction.tuna_position_owner_ata_b.expect("tuna_position_owner_ata_b is not set"),
1282
1283 fee_recipient_ata_a: self.instruction.fee_recipient_ata_a.expect("fee_recipient_ata_a is not set"),
1284
1285 fee_recipient_ata_b: self.instruction.fee_recipient_ata_b.expect("fee_recipient_ata_b is not set"),
1286
1287 pyth_oracle_price_feed_a: self.instruction.pyth_oracle_price_feed_a.expect("pyth_oracle_price_feed_a is not set"),
1288
1289 pyth_oracle_price_feed_b: self.instruction.pyth_oracle_price_feed_b.expect("pyth_oracle_price_feed_b is not set"),
1290
1291 pool: self.instruction.pool.expect("pool is not set"),
1292
1293 jupiter_program: self.instruction.jupiter_program.expect("jupiter_program is not set"),
1294
1295 jupiter_event_authority: self.instruction.jupiter_event_authority.expect("jupiter_event_authority is not set"),
1296
1297 jupiter_program_authority: self.instruction.jupiter_program_authority.expect("jupiter_program_authority is not set"),
1298
1299 token_program: self.instruction.token_program.expect("token_program is not set"),
1300
1301 memo_program: self.instruction.memo_program.expect("memo_program is not set"),
1302
1303 system_program: self.instruction.system_program.expect("system_program is not set"),
1304 __args: args,
1305 };
1306 instruction.invoke_signed_with_remaining_accounts(signers_seeds, &self.instruction.__remaining_accounts)
1307 }
1308}
1309
1310#[derive(Clone, Debug)]
1311struct ModifyTunaSpotPositionJupiterCpiBuilderInstruction<'a, 'b> {
1312 __program: &'b solana_account_info::AccountInfo<'a>,
1313 authority: Option<&'b solana_account_info::AccountInfo<'a>>,
1314 tuna_config: Option<&'b solana_account_info::AccountInfo<'a>>,
1315 mint_a: Option<&'b solana_account_info::AccountInfo<'a>>,
1316 mint_b: Option<&'b solana_account_info::AccountInfo<'a>>,
1317 token_program_a: Option<&'b solana_account_info::AccountInfo<'a>>,
1318 token_program_b: Option<&'b solana_account_info::AccountInfo<'a>>,
1319 market: Option<&'b solana_account_info::AccountInfo<'a>>,
1320 vault_a: Option<&'b solana_account_info::AccountInfo<'a>>,
1321 vault_b: Option<&'b solana_account_info::AccountInfo<'a>>,
1322 vault_a_ata: Option<&'b solana_account_info::AccountInfo<'a>>,
1323 vault_b_ata: Option<&'b solana_account_info::AccountInfo<'a>>,
1324 tuna_position: Option<&'b solana_account_info::AccountInfo<'a>>,
1325 tuna_position_ata_a: Option<&'b solana_account_info::AccountInfo<'a>>,
1326 tuna_position_ata_b: Option<&'b solana_account_info::AccountInfo<'a>>,
1327 tuna_position_owner_ata_a: Option<&'b solana_account_info::AccountInfo<'a>>,
1328 tuna_position_owner_ata_b: Option<&'b solana_account_info::AccountInfo<'a>>,
1329 fee_recipient_ata_a: Option<&'b solana_account_info::AccountInfo<'a>>,
1330 fee_recipient_ata_b: Option<&'b solana_account_info::AccountInfo<'a>>,
1331 pyth_oracle_price_feed_a: Option<&'b solana_account_info::AccountInfo<'a>>,
1332 pyth_oracle_price_feed_b: Option<&'b solana_account_info::AccountInfo<'a>>,
1333 pool: Option<&'b solana_account_info::AccountInfo<'a>>,
1334 jupiter_program: Option<&'b solana_account_info::AccountInfo<'a>>,
1335 jupiter_event_authority: Option<&'b solana_account_info::AccountInfo<'a>>,
1336 jupiter_program_authority: Option<&'b solana_account_info::AccountInfo<'a>>,
1337 token_program: Option<&'b solana_account_info::AccountInfo<'a>>,
1338 memo_program: Option<&'b solana_account_info::AccountInfo<'a>>,
1339 system_program: Option<&'b solana_account_info::AccountInfo<'a>>,
1340 decrease_percent: Option<u32>,
1341 collateral_amount: Option<u64>,
1342 borrow_amount: Option<u64>,
1343 route_data: Option<Vec<u8>>,
1344 __remaining_accounts: Vec<(&'b solana_account_info::AccountInfo<'a>, bool, bool)>,
1346}
1347