1use crate::generated::types::RemainingAccountsInfo;
9use borsh::BorshSerialize;
10use borsh::BorshDeserialize;
11
12#[derive(Debug)]
14pub struct OpenPositionWithLiquidityFusion {
15 pub authority: solana_program::pubkey::Pubkey,
22
23
24 pub tuna_config: solana_program::pubkey::Pubkey,
25
26
27 pub mint_a: solana_program::pubkey::Pubkey,
28
29
30 pub mint_b: solana_program::pubkey::Pubkey,
31
32
33 pub token_program_a: solana_program::pubkey::Pubkey,
34
35
36 pub token_program_b: solana_program::pubkey::Pubkey,
37
38
39 pub market: solana_program::pubkey::Pubkey,
40
41
42 pub vault_a: solana_program::pubkey::Pubkey,
43
44
45 pub vault_b: solana_program::pubkey::Pubkey,
46
47
48 pub vault_a_ata: solana_program::pubkey::Pubkey,
49
50
51 pub vault_b_ata: solana_program::pubkey::Pubkey,
52
53
54 pub tuna_position: solana_program::pubkey::Pubkey,
55
56
57 pub tuna_position_mint: solana_program::pubkey::Pubkey,
58
59
60 pub tuna_position_ata: solana_program::pubkey::Pubkey,
61
62
63 pub tuna_position_ata_a: solana_program::pubkey::Pubkey,
64
65
66 pub tuna_position_ata_b: solana_program::pubkey::Pubkey,
67
68
69 pub tuna_position_owner_ata_a: solana_program::pubkey::Pubkey,
70
71
72 pub tuna_position_owner_ata_b: solana_program::pubkey::Pubkey,
73
74
75 pub fee_recipient_ata_a: solana_program::pubkey::Pubkey,
76
77
78 pub fee_recipient_ata_b: solana_program::pubkey::Pubkey,
79
80
81 pub pyth_oracle_price_feed_a: solana_program::pubkey::Pubkey,
82
83
84 pub pyth_oracle_price_feed_b: solana_program::pubkey::Pubkey,
85 pub fusionamm_program: solana_program::pubkey::Pubkey,
92
93
94 pub fusion_pool: solana_program::pubkey::Pubkey,
95
96
97 pub fusion_position: solana_program::pubkey::Pubkey,
98
99
100 pub metadata_update_auth: solana_program::pubkey::Pubkey,
101
102
103 pub memo_program: solana_program::pubkey::Pubkey,
104 pub token2022_program: solana_program::pubkey::Pubkey,
111
112
113 pub system_program: solana_program::pubkey::Pubkey,
114
115
116 pub associated_token_program: solana_program::pubkey::Pubkey,
117 }
118
119impl OpenPositionWithLiquidityFusion {
120 pub fn instruction(&self, args: OpenPositionWithLiquidityFusionInstructionArgs) -> solana_program::instruction::Instruction {
121 self.instruction_with_remaining_accounts(args, &[])
122 }
123 #[allow(clippy::arithmetic_side_effects)]
124 #[allow(clippy::vec_init_then_push)]
125 pub fn instruction_with_remaining_accounts(&self, args: OpenPositionWithLiquidityFusionInstructionArgs, remaining_accounts: &[solana_program::instruction::AccountMeta]) -> solana_program::instruction::Instruction {
126 let mut accounts = Vec::with_capacity(30+ remaining_accounts.len());
127 accounts.push(solana_program::instruction::AccountMeta::new(
128 self.authority,
129 true
130 ));
131 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
132 self.tuna_config,
133 false
134 ));
135 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
136 self.mint_a,
137 false
138 ));
139 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
140 self.mint_b,
141 false
142 ));
143 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
144 self.token_program_a,
145 false
146 ));
147 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
148 self.token_program_b,
149 false
150 ));
151 accounts.push(solana_program::instruction::AccountMeta::new(
152 self.market,
153 false
154 ));
155 accounts.push(solana_program::instruction::AccountMeta::new(
156 self.vault_a,
157 false
158 ));
159 accounts.push(solana_program::instruction::AccountMeta::new(
160 self.vault_b,
161 false
162 ));
163 accounts.push(solana_program::instruction::AccountMeta::new(
164 self.vault_a_ata,
165 false
166 ));
167 accounts.push(solana_program::instruction::AccountMeta::new(
168 self.vault_b_ata,
169 false
170 ));
171 accounts.push(solana_program::instruction::AccountMeta::new(
172 self.tuna_position,
173 false
174 ));
175 accounts.push(solana_program::instruction::AccountMeta::new(
176 self.tuna_position_mint,
177 true
178 ));
179 accounts.push(solana_program::instruction::AccountMeta::new(
180 self.tuna_position_ata,
181 false
182 ));
183 accounts.push(solana_program::instruction::AccountMeta::new(
184 self.tuna_position_ata_a,
185 false
186 ));
187 accounts.push(solana_program::instruction::AccountMeta::new(
188 self.tuna_position_ata_b,
189 false
190 ));
191 accounts.push(solana_program::instruction::AccountMeta::new(
192 self.tuna_position_owner_ata_a,
193 false
194 ));
195 accounts.push(solana_program::instruction::AccountMeta::new(
196 self.tuna_position_owner_ata_b,
197 false
198 ));
199 accounts.push(solana_program::instruction::AccountMeta::new(
200 self.fee_recipient_ata_a,
201 false
202 ));
203 accounts.push(solana_program::instruction::AccountMeta::new(
204 self.fee_recipient_ata_b,
205 false
206 ));
207 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
208 self.pyth_oracle_price_feed_a,
209 false
210 ));
211 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
212 self.pyth_oracle_price_feed_b,
213 false
214 ));
215 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
216 self.fusionamm_program,
217 false
218 ));
219 accounts.push(solana_program::instruction::AccountMeta::new(
220 self.fusion_pool,
221 false
222 ));
223 accounts.push(solana_program::instruction::AccountMeta::new(
224 self.fusion_position,
225 false
226 ));
227 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
228 self.metadata_update_auth,
229 false
230 ));
231 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
232 self.memo_program,
233 false
234 ));
235 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
236 self.token2022_program,
237 false
238 ));
239 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
240 self.system_program,
241 false
242 ));
243 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
244 self.associated_token_program,
245 false
246 ));
247 accounts.extend_from_slice(remaining_accounts);
248 let mut data = borsh::to_vec(&OpenPositionWithLiquidityFusionInstructionData::new()).unwrap();
249 let mut args = borsh::to_vec(&args).unwrap();
250 data.append(&mut args);
251
252 solana_program::instruction::Instruction {
253 program_id: crate::TUNA_ID,
254 accounts,
255 data,
256 }
257 }
258}
259
260#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
261#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
262 pub struct OpenPositionWithLiquidityFusionInstructionData {
263 discriminator: [u8; 8],
264 }
265
266impl OpenPositionWithLiquidityFusionInstructionData {
267 pub fn new() -> Self {
268 Self {
269 discriminator: [123, 115, 192, 91, 113, 191, 73, 56],
270 }
271 }
272}
273
274impl Default for OpenPositionWithLiquidityFusionInstructionData {
275 fn default() -> Self {
276 Self::new()
277 }
278}
279
280#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
281#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
282 pub struct OpenPositionWithLiquidityFusionInstructionArgs {
283 pub tick_lower_index: i32,
284 pub tick_upper_index: i32,
285 pub tick_stop_loss_index: i32,
286 pub tick_take_profit_index: i32,
287 pub flags: u32,
288 pub collateral_a: u64,
289 pub collateral_b: u64,
290 pub borrow_a: u64,
291 pub borrow_b: u64,
292 pub min_added_amount_a: u64,
293 pub min_added_amount_b: u64,
294 pub max_swap_slippage: u32,
295 pub remaining_accounts_info: RemainingAccountsInfo,
296 }
297
298
299#[derive(Clone, Debug, Default)]
334pub struct OpenPositionWithLiquidityFusionBuilder {
335 authority: Option<solana_program::pubkey::Pubkey>,
336 tuna_config: Option<solana_program::pubkey::Pubkey>,
337 mint_a: Option<solana_program::pubkey::Pubkey>,
338 mint_b: Option<solana_program::pubkey::Pubkey>,
339 token_program_a: Option<solana_program::pubkey::Pubkey>,
340 token_program_b: Option<solana_program::pubkey::Pubkey>,
341 market: Option<solana_program::pubkey::Pubkey>,
342 vault_a: Option<solana_program::pubkey::Pubkey>,
343 vault_b: Option<solana_program::pubkey::Pubkey>,
344 vault_a_ata: Option<solana_program::pubkey::Pubkey>,
345 vault_b_ata: Option<solana_program::pubkey::Pubkey>,
346 tuna_position: Option<solana_program::pubkey::Pubkey>,
347 tuna_position_mint: Option<solana_program::pubkey::Pubkey>,
348 tuna_position_ata: Option<solana_program::pubkey::Pubkey>,
349 tuna_position_ata_a: Option<solana_program::pubkey::Pubkey>,
350 tuna_position_ata_b: Option<solana_program::pubkey::Pubkey>,
351 tuna_position_owner_ata_a: Option<solana_program::pubkey::Pubkey>,
352 tuna_position_owner_ata_b: Option<solana_program::pubkey::Pubkey>,
353 fee_recipient_ata_a: Option<solana_program::pubkey::Pubkey>,
354 fee_recipient_ata_b: Option<solana_program::pubkey::Pubkey>,
355 pyth_oracle_price_feed_a: Option<solana_program::pubkey::Pubkey>,
356 pyth_oracle_price_feed_b: Option<solana_program::pubkey::Pubkey>,
357 fusionamm_program: Option<solana_program::pubkey::Pubkey>,
358 fusion_pool: Option<solana_program::pubkey::Pubkey>,
359 fusion_position: Option<solana_program::pubkey::Pubkey>,
360 metadata_update_auth: Option<solana_program::pubkey::Pubkey>,
361 memo_program: Option<solana_program::pubkey::Pubkey>,
362 token2022_program: Option<solana_program::pubkey::Pubkey>,
363 system_program: Option<solana_program::pubkey::Pubkey>,
364 associated_token_program: Option<solana_program::pubkey::Pubkey>,
365 tick_lower_index: Option<i32>,
366 tick_upper_index: Option<i32>,
367 tick_stop_loss_index: Option<i32>,
368 tick_take_profit_index: Option<i32>,
369 flags: Option<u32>,
370 collateral_a: Option<u64>,
371 collateral_b: Option<u64>,
372 borrow_a: Option<u64>,
373 borrow_b: Option<u64>,
374 min_added_amount_a: Option<u64>,
375 min_added_amount_b: Option<u64>,
376 max_swap_slippage: Option<u32>,
377 remaining_accounts_info: Option<RemainingAccountsInfo>,
378 __remaining_accounts: Vec<solana_program::instruction::AccountMeta>,
379}
380
381impl OpenPositionWithLiquidityFusionBuilder {
382 pub fn new() -> Self {
383 Self::default()
384 }
385 #[inline(always)]
389 pub fn authority(&mut self, authority: solana_program::pubkey::Pubkey) -> &mut Self {
390 self.authority = Some(authority);
391 self
392 }
393 #[inline(always)]
394 pub fn tuna_config(&mut self, tuna_config: solana_program::pubkey::Pubkey) -> &mut Self {
395 self.tuna_config = Some(tuna_config);
396 self
397 }
398 #[inline(always)]
399 pub fn mint_a(&mut self, mint_a: solana_program::pubkey::Pubkey) -> &mut Self {
400 self.mint_a = Some(mint_a);
401 self
402 }
403 #[inline(always)]
404 pub fn mint_b(&mut self, mint_b: solana_program::pubkey::Pubkey) -> &mut Self {
405 self.mint_b = Some(mint_b);
406 self
407 }
408 #[inline(always)]
409 pub fn token_program_a(&mut self, token_program_a: solana_program::pubkey::Pubkey) -> &mut Self {
410 self.token_program_a = Some(token_program_a);
411 self
412 }
413 #[inline(always)]
414 pub fn token_program_b(&mut self, token_program_b: solana_program::pubkey::Pubkey) -> &mut Self {
415 self.token_program_b = Some(token_program_b);
416 self
417 }
418 #[inline(always)]
419 pub fn market(&mut self, market: solana_program::pubkey::Pubkey) -> &mut Self {
420 self.market = Some(market);
421 self
422 }
423 #[inline(always)]
424 pub fn vault_a(&mut self, vault_a: solana_program::pubkey::Pubkey) -> &mut Self {
425 self.vault_a = Some(vault_a);
426 self
427 }
428 #[inline(always)]
429 pub fn vault_b(&mut self, vault_b: solana_program::pubkey::Pubkey) -> &mut Self {
430 self.vault_b = Some(vault_b);
431 self
432 }
433 #[inline(always)]
434 pub fn vault_a_ata(&mut self, vault_a_ata: solana_program::pubkey::Pubkey) -> &mut Self {
435 self.vault_a_ata = Some(vault_a_ata);
436 self
437 }
438 #[inline(always)]
439 pub fn vault_b_ata(&mut self, vault_b_ata: solana_program::pubkey::Pubkey) -> &mut Self {
440 self.vault_b_ata = Some(vault_b_ata);
441 self
442 }
443 #[inline(always)]
444 pub fn tuna_position(&mut self, tuna_position: solana_program::pubkey::Pubkey) -> &mut Self {
445 self.tuna_position = Some(tuna_position);
446 self
447 }
448 #[inline(always)]
449 pub fn tuna_position_mint(&mut self, tuna_position_mint: solana_program::pubkey::Pubkey) -> &mut Self {
450 self.tuna_position_mint = Some(tuna_position_mint);
451 self
452 }
453 #[inline(always)]
454 pub fn tuna_position_ata(&mut self, tuna_position_ata: solana_program::pubkey::Pubkey) -> &mut Self {
455 self.tuna_position_ata = Some(tuna_position_ata);
456 self
457 }
458 #[inline(always)]
459 pub fn tuna_position_ata_a(&mut self, tuna_position_ata_a: solana_program::pubkey::Pubkey) -> &mut Self {
460 self.tuna_position_ata_a = Some(tuna_position_ata_a);
461 self
462 }
463 #[inline(always)]
464 pub fn tuna_position_ata_b(&mut self, tuna_position_ata_b: solana_program::pubkey::Pubkey) -> &mut Self {
465 self.tuna_position_ata_b = Some(tuna_position_ata_b);
466 self
467 }
468 #[inline(always)]
469 pub fn tuna_position_owner_ata_a(&mut self, tuna_position_owner_ata_a: solana_program::pubkey::Pubkey) -> &mut Self {
470 self.tuna_position_owner_ata_a = Some(tuna_position_owner_ata_a);
471 self
472 }
473 #[inline(always)]
474 pub fn tuna_position_owner_ata_b(&mut self, tuna_position_owner_ata_b: solana_program::pubkey::Pubkey) -> &mut Self {
475 self.tuna_position_owner_ata_b = Some(tuna_position_owner_ata_b);
476 self
477 }
478 #[inline(always)]
479 pub fn fee_recipient_ata_a(&mut self, fee_recipient_ata_a: solana_program::pubkey::Pubkey) -> &mut Self {
480 self.fee_recipient_ata_a = Some(fee_recipient_ata_a);
481 self
482 }
483 #[inline(always)]
484 pub fn fee_recipient_ata_b(&mut self, fee_recipient_ata_b: solana_program::pubkey::Pubkey) -> &mut Self {
485 self.fee_recipient_ata_b = Some(fee_recipient_ata_b);
486 self
487 }
488 #[inline(always)]
489 pub fn pyth_oracle_price_feed_a(&mut self, pyth_oracle_price_feed_a: solana_program::pubkey::Pubkey) -> &mut Self {
490 self.pyth_oracle_price_feed_a = Some(pyth_oracle_price_feed_a);
491 self
492 }
493 #[inline(always)]
494 pub fn pyth_oracle_price_feed_b(&mut self, pyth_oracle_price_feed_b: solana_program::pubkey::Pubkey) -> &mut Self {
495 self.pyth_oracle_price_feed_b = Some(pyth_oracle_price_feed_b);
496 self
497 }
498 #[inline(always)]
502 pub fn fusionamm_program(&mut self, fusionamm_program: solana_program::pubkey::Pubkey) -> &mut Self {
503 self.fusionamm_program = Some(fusionamm_program);
504 self
505 }
506 #[inline(always)]
507 pub fn fusion_pool(&mut self, fusion_pool: solana_program::pubkey::Pubkey) -> &mut Self {
508 self.fusion_pool = Some(fusion_pool);
509 self
510 }
511 #[inline(always)]
512 pub fn fusion_position(&mut self, fusion_position: solana_program::pubkey::Pubkey) -> &mut Self {
513 self.fusion_position = Some(fusion_position);
514 self
515 }
516 #[inline(always)]
517 pub fn metadata_update_auth(&mut self, metadata_update_auth: solana_program::pubkey::Pubkey) -> &mut Self {
518 self.metadata_update_auth = Some(metadata_update_auth);
519 self
520 }
521 #[inline(always)]
522 pub fn memo_program(&mut self, memo_program: solana_program::pubkey::Pubkey) -> &mut Self {
523 self.memo_program = Some(memo_program);
524 self
525 }
526 #[inline(always)]
530 pub fn token2022_program(&mut self, token2022_program: solana_program::pubkey::Pubkey) -> &mut Self {
531 self.token2022_program = Some(token2022_program);
532 self
533 }
534 #[inline(always)]
536 pub fn system_program(&mut self, system_program: solana_program::pubkey::Pubkey) -> &mut Self {
537 self.system_program = Some(system_program);
538 self
539 }
540 #[inline(always)]
541 pub fn associated_token_program(&mut self, associated_token_program: solana_program::pubkey::Pubkey) -> &mut Self {
542 self.associated_token_program = Some(associated_token_program);
543 self
544 }
545 #[inline(always)]
546 pub fn tick_lower_index(&mut self, tick_lower_index: i32) -> &mut Self {
547 self.tick_lower_index = Some(tick_lower_index);
548 self
549 }
550 #[inline(always)]
551 pub fn tick_upper_index(&mut self, tick_upper_index: i32) -> &mut Self {
552 self.tick_upper_index = Some(tick_upper_index);
553 self
554 }
555 #[inline(always)]
556 pub fn tick_stop_loss_index(&mut self, tick_stop_loss_index: i32) -> &mut Self {
557 self.tick_stop_loss_index = Some(tick_stop_loss_index);
558 self
559 }
560 #[inline(always)]
561 pub fn tick_take_profit_index(&mut self, tick_take_profit_index: i32) -> &mut Self {
562 self.tick_take_profit_index = Some(tick_take_profit_index);
563 self
564 }
565 #[inline(always)]
566 pub fn flags(&mut self, flags: u32) -> &mut Self {
567 self.flags = Some(flags);
568 self
569 }
570 #[inline(always)]
571 pub fn collateral_a(&mut self, collateral_a: u64) -> &mut Self {
572 self.collateral_a = Some(collateral_a);
573 self
574 }
575 #[inline(always)]
576 pub fn collateral_b(&mut self, collateral_b: u64) -> &mut Self {
577 self.collateral_b = Some(collateral_b);
578 self
579 }
580 #[inline(always)]
581 pub fn borrow_a(&mut self, borrow_a: u64) -> &mut Self {
582 self.borrow_a = Some(borrow_a);
583 self
584 }
585 #[inline(always)]
586 pub fn borrow_b(&mut self, borrow_b: u64) -> &mut Self {
587 self.borrow_b = Some(borrow_b);
588 self
589 }
590 #[inline(always)]
591 pub fn min_added_amount_a(&mut self, min_added_amount_a: u64) -> &mut Self {
592 self.min_added_amount_a = Some(min_added_amount_a);
593 self
594 }
595 #[inline(always)]
596 pub fn min_added_amount_b(&mut self, min_added_amount_b: u64) -> &mut Self {
597 self.min_added_amount_b = Some(min_added_amount_b);
598 self
599 }
600 #[inline(always)]
601 pub fn max_swap_slippage(&mut self, max_swap_slippage: u32) -> &mut Self {
602 self.max_swap_slippage = Some(max_swap_slippage);
603 self
604 }
605 #[inline(always)]
606 pub fn remaining_accounts_info(&mut self, remaining_accounts_info: RemainingAccountsInfo) -> &mut Self {
607 self.remaining_accounts_info = Some(remaining_accounts_info);
608 self
609 }
610 #[inline(always)]
612 pub fn add_remaining_account(&mut self, account: solana_program::instruction::AccountMeta) -> &mut Self {
613 self.__remaining_accounts.push(account);
614 self
615 }
616 #[inline(always)]
618 pub fn add_remaining_accounts(&mut self, accounts: &[solana_program::instruction::AccountMeta]) -> &mut Self {
619 self.__remaining_accounts.extend_from_slice(accounts);
620 self
621 }
622 #[allow(clippy::clone_on_copy)]
623 pub fn instruction(&self) -> solana_program::instruction::Instruction {
624 let accounts = OpenPositionWithLiquidityFusion {
625 authority: self.authority.expect("authority is not set"),
626 tuna_config: self.tuna_config.expect("tuna_config is not set"),
627 mint_a: self.mint_a.expect("mint_a is not set"),
628 mint_b: self.mint_b.expect("mint_b is not set"),
629 token_program_a: self.token_program_a.expect("token_program_a is not set"),
630 token_program_b: self.token_program_b.expect("token_program_b is not set"),
631 market: self.market.expect("market is not set"),
632 vault_a: self.vault_a.expect("vault_a is not set"),
633 vault_b: self.vault_b.expect("vault_b is not set"),
634 vault_a_ata: self.vault_a_ata.expect("vault_a_ata is not set"),
635 vault_b_ata: self.vault_b_ata.expect("vault_b_ata is not set"),
636 tuna_position: self.tuna_position.expect("tuna_position is not set"),
637 tuna_position_mint: self.tuna_position_mint.expect("tuna_position_mint is not set"),
638 tuna_position_ata: self.tuna_position_ata.expect("tuna_position_ata is not set"),
639 tuna_position_ata_a: self.tuna_position_ata_a.expect("tuna_position_ata_a is not set"),
640 tuna_position_ata_b: self.tuna_position_ata_b.expect("tuna_position_ata_b is not set"),
641 tuna_position_owner_ata_a: self.tuna_position_owner_ata_a.expect("tuna_position_owner_ata_a is not set"),
642 tuna_position_owner_ata_b: self.tuna_position_owner_ata_b.expect("tuna_position_owner_ata_b is not set"),
643 fee_recipient_ata_a: self.fee_recipient_ata_a.expect("fee_recipient_ata_a is not set"),
644 fee_recipient_ata_b: self.fee_recipient_ata_b.expect("fee_recipient_ata_b is not set"),
645 pyth_oracle_price_feed_a: self.pyth_oracle_price_feed_a.expect("pyth_oracle_price_feed_a is not set"),
646 pyth_oracle_price_feed_b: self.pyth_oracle_price_feed_b.expect("pyth_oracle_price_feed_b is not set"),
647 fusionamm_program: self.fusionamm_program.expect("fusionamm_program is not set"),
648 fusion_pool: self.fusion_pool.expect("fusion_pool is not set"),
649 fusion_position: self.fusion_position.expect("fusion_position is not set"),
650 metadata_update_auth: self.metadata_update_auth.expect("metadata_update_auth is not set"),
651 memo_program: self.memo_program.expect("memo_program is not set"),
652 token2022_program: self.token2022_program.expect("token2022_program is not set"),
653 system_program: self.system_program.unwrap_or(solana_program::pubkey!("11111111111111111111111111111111")),
654 associated_token_program: self.associated_token_program.expect("associated_token_program is not set"),
655 };
656 let args = OpenPositionWithLiquidityFusionInstructionArgs {
657 tick_lower_index: self.tick_lower_index.clone().expect("tick_lower_index is not set"),
658 tick_upper_index: self.tick_upper_index.clone().expect("tick_upper_index is not set"),
659 tick_stop_loss_index: self.tick_stop_loss_index.clone().expect("tick_stop_loss_index is not set"),
660 tick_take_profit_index: self.tick_take_profit_index.clone().expect("tick_take_profit_index is not set"),
661 flags: self.flags.clone().expect("flags is not set"),
662 collateral_a: self.collateral_a.clone().expect("collateral_a is not set"),
663 collateral_b: self.collateral_b.clone().expect("collateral_b is not set"),
664 borrow_a: self.borrow_a.clone().expect("borrow_a is not set"),
665 borrow_b: self.borrow_b.clone().expect("borrow_b is not set"),
666 min_added_amount_a: self.min_added_amount_a.clone().expect("min_added_amount_a is not set"),
667 min_added_amount_b: self.min_added_amount_b.clone().expect("min_added_amount_b is not set"),
668 max_swap_slippage: self.max_swap_slippage.clone().expect("max_swap_slippage is not set"),
669 remaining_accounts_info: self.remaining_accounts_info.clone().expect("remaining_accounts_info is not set"),
670 };
671
672 accounts.instruction_with_remaining_accounts(args, &self.__remaining_accounts)
673 }
674}
675
676 pub struct OpenPositionWithLiquidityFusionCpiAccounts<'a, 'b> {
678 pub authority: &'b solana_program::account_info::AccountInfo<'a>,
685
686
687 pub tuna_config: &'b solana_program::account_info::AccountInfo<'a>,
688
689
690 pub mint_a: &'b solana_program::account_info::AccountInfo<'a>,
691
692
693 pub mint_b: &'b solana_program::account_info::AccountInfo<'a>,
694
695
696 pub token_program_a: &'b solana_program::account_info::AccountInfo<'a>,
697
698
699 pub token_program_b: &'b solana_program::account_info::AccountInfo<'a>,
700
701
702 pub market: &'b solana_program::account_info::AccountInfo<'a>,
703
704
705 pub vault_a: &'b solana_program::account_info::AccountInfo<'a>,
706
707
708 pub vault_b: &'b solana_program::account_info::AccountInfo<'a>,
709
710
711 pub vault_a_ata: &'b solana_program::account_info::AccountInfo<'a>,
712
713
714 pub vault_b_ata: &'b solana_program::account_info::AccountInfo<'a>,
715
716
717 pub tuna_position: &'b solana_program::account_info::AccountInfo<'a>,
718
719
720 pub tuna_position_mint: &'b solana_program::account_info::AccountInfo<'a>,
721
722
723 pub tuna_position_ata: &'b solana_program::account_info::AccountInfo<'a>,
724
725
726 pub tuna_position_ata_a: &'b solana_program::account_info::AccountInfo<'a>,
727
728
729 pub tuna_position_ata_b: &'b solana_program::account_info::AccountInfo<'a>,
730
731
732 pub tuna_position_owner_ata_a: &'b solana_program::account_info::AccountInfo<'a>,
733
734
735 pub tuna_position_owner_ata_b: &'b solana_program::account_info::AccountInfo<'a>,
736
737
738 pub fee_recipient_ata_a: &'b solana_program::account_info::AccountInfo<'a>,
739
740
741 pub fee_recipient_ata_b: &'b solana_program::account_info::AccountInfo<'a>,
742
743
744 pub pyth_oracle_price_feed_a: &'b solana_program::account_info::AccountInfo<'a>,
745
746
747 pub pyth_oracle_price_feed_b: &'b solana_program::account_info::AccountInfo<'a>,
748 pub fusionamm_program: &'b solana_program::account_info::AccountInfo<'a>,
755
756
757 pub fusion_pool: &'b solana_program::account_info::AccountInfo<'a>,
758
759
760 pub fusion_position: &'b solana_program::account_info::AccountInfo<'a>,
761
762
763 pub metadata_update_auth: &'b solana_program::account_info::AccountInfo<'a>,
764
765
766 pub memo_program: &'b solana_program::account_info::AccountInfo<'a>,
767 pub token2022_program: &'b solana_program::account_info::AccountInfo<'a>,
774
775
776 pub system_program: &'b solana_program::account_info::AccountInfo<'a>,
777
778
779 pub associated_token_program: &'b solana_program::account_info::AccountInfo<'a>,
780 }
781
782pub struct OpenPositionWithLiquidityFusionCpi<'a, 'b> {
784 pub __program: &'b solana_program::account_info::AccountInfo<'a>,
786 pub authority: &'b solana_program::account_info::AccountInfo<'a>,
793
794
795 pub tuna_config: &'b solana_program::account_info::AccountInfo<'a>,
796
797
798 pub mint_a: &'b solana_program::account_info::AccountInfo<'a>,
799
800
801 pub mint_b: &'b solana_program::account_info::AccountInfo<'a>,
802
803
804 pub token_program_a: &'b solana_program::account_info::AccountInfo<'a>,
805
806
807 pub token_program_b: &'b solana_program::account_info::AccountInfo<'a>,
808
809
810 pub market: &'b solana_program::account_info::AccountInfo<'a>,
811
812
813 pub vault_a: &'b solana_program::account_info::AccountInfo<'a>,
814
815
816 pub vault_b: &'b solana_program::account_info::AccountInfo<'a>,
817
818
819 pub vault_a_ata: &'b solana_program::account_info::AccountInfo<'a>,
820
821
822 pub vault_b_ata: &'b solana_program::account_info::AccountInfo<'a>,
823
824
825 pub tuna_position: &'b solana_program::account_info::AccountInfo<'a>,
826
827
828 pub tuna_position_mint: &'b solana_program::account_info::AccountInfo<'a>,
829
830
831 pub tuna_position_ata: &'b solana_program::account_info::AccountInfo<'a>,
832
833
834 pub tuna_position_ata_a: &'b solana_program::account_info::AccountInfo<'a>,
835
836
837 pub tuna_position_ata_b: &'b solana_program::account_info::AccountInfo<'a>,
838
839
840 pub tuna_position_owner_ata_a: &'b solana_program::account_info::AccountInfo<'a>,
841
842
843 pub tuna_position_owner_ata_b: &'b solana_program::account_info::AccountInfo<'a>,
844
845
846 pub fee_recipient_ata_a: &'b solana_program::account_info::AccountInfo<'a>,
847
848
849 pub fee_recipient_ata_b: &'b solana_program::account_info::AccountInfo<'a>,
850
851
852 pub pyth_oracle_price_feed_a: &'b solana_program::account_info::AccountInfo<'a>,
853
854
855 pub pyth_oracle_price_feed_b: &'b solana_program::account_info::AccountInfo<'a>,
856 pub fusionamm_program: &'b solana_program::account_info::AccountInfo<'a>,
863
864
865 pub fusion_pool: &'b solana_program::account_info::AccountInfo<'a>,
866
867
868 pub fusion_position: &'b solana_program::account_info::AccountInfo<'a>,
869
870
871 pub metadata_update_auth: &'b solana_program::account_info::AccountInfo<'a>,
872
873
874 pub memo_program: &'b solana_program::account_info::AccountInfo<'a>,
875 pub token2022_program: &'b solana_program::account_info::AccountInfo<'a>,
882
883
884 pub system_program: &'b solana_program::account_info::AccountInfo<'a>,
885
886
887 pub associated_token_program: &'b solana_program::account_info::AccountInfo<'a>,
888 pub __args: OpenPositionWithLiquidityFusionInstructionArgs,
890 }
891
892impl<'a, 'b> OpenPositionWithLiquidityFusionCpi<'a, 'b> {
893 pub fn new(
894 program: &'b solana_program::account_info::AccountInfo<'a>,
895 accounts: OpenPositionWithLiquidityFusionCpiAccounts<'a, 'b>,
896 args: OpenPositionWithLiquidityFusionInstructionArgs,
897 ) -> Self {
898 Self {
899 __program: program,
900 authority: accounts.authority,
901 tuna_config: accounts.tuna_config,
902 mint_a: accounts.mint_a,
903 mint_b: accounts.mint_b,
904 token_program_a: accounts.token_program_a,
905 token_program_b: accounts.token_program_b,
906 market: accounts.market,
907 vault_a: accounts.vault_a,
908 vault_b: accounts.vault_b,
909 vault_a_ata: accounts.vault_a_ata,
910 vault_b_ata: accounts.vault_b_ata,
911 tuna_position: accounts.tuna_position,
912 tuna_position_mint: accounts.tuna_position_mint,
913 tuna_position_ata: accounts.tuna_position_ata,
914 tuna_position_ata_a: accounts.tuna_position_ata_a,
915 tuna_position_ata_b: accounts.tuna_position_ata_b,
916 tuna_position_owner_ata_a: accounts.tuna_position_owner_ata_a,
917 tuna_position_owner_ata_b: accounts.tuna_position_owner_ata_b,
918 fee_recipient_ata_a: accounts.fee_recipient_ata_a,
919 fee_recipient_ata_b: accounts.fee_recipient_ata_b,
920 pyth_oracle_price_feed_a: accounts.pyth_oracle_price_feed_a,
921 pyth_oracle_price_feed_b: accounts.pyth_oracle_price_feed_b,
922 fusionamm_program: accounts.fusionamm_program,
923 fusion_pool: accounts.fusion_pool,
924 fusion_position: accounts.fusion_position,
925 metadata_update_auth: accounts.metadata_update_auth,
926 memo_program: accounts.memo_program,
927 token2022_program: accounts.token2022_program,
928 system_program: accounts.system_program,
929 associated_token_program: accounts.associated_token_program,
930 __args: args,
931 }
932 }
933 #[inline(always)]
934 pub fn invoke(&self) -> solana_program::entrypoint::ProgramResult {
935 self.invoke_signed_with_remaining_accounts(&[], &[])
936 }
937 #[inline(always)]
938 pub fn invoke_with_remaining_accounts(&self, remaining_accounts: &[(&'b solana_program::account_info::AccountInfo<'a>, bool, bool)]) -> solana_program::entrypoint::ProgramResult {
939 self.invoke_signed_with_remaining_accounts(&[], remaining_accounts)
940 }
941 #[inline(always)]
942 pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program::entrypoint::ProgramResult {
943 self.invoke_signed_with_remaining_accounts(signers_seeds, &[])
944 }
945 #[allow(clippy::arithmetic_side_effects)]
946 #[allow(clippy::clone_on_copy)]
947 #[allow(clippy::vec_init_then_push)]
948 pub fn invoke_signed_with_remaining_accounts(
949 &self,
950 signers_seeds: &[&[&[u8]]],
951 remaining_accounts: &[(&'b solana_program::account_info::AccountInfo<'a>, bool, bool)]
952 ) -> solana_program::entrypoint::ProgramResult {
953 let mut accounts = Vec::with_capacity(30+ remaining_accounts.len());
954 accounts.push(solana_program::instruction::AccountMeta::new(
955 *self.authority.key,
956 true
957 ));
958 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
959 *self.tuna_config.key,
960 false
961 ));
962 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
963 *self.mint_a.key,
964 false
965 ));
966 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
967 *self.mint_b.key,
968 false
969 ));
970 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
971 *self.token_program_a.key,
972 false
973 ));
974 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
975 *self.token_program_b.key,
976 false
977 ));
978 accounts.push(solana_program::instruction::AccountMeta::new(
979 *self.market.key,
980 false
981 ));
982 accounts.push(solana_program::instruction::AccountMeta::new(
983 *self.vault_a.key,
984 false
985 ));
986 accounts.push(solana_program::instruction::AccountMeta::new(
987 *self.vault_b.key,
988 false
989 ));
990 accounts.push(solana_program::instruction::AccountMeta::new(
991 *self.vault_a_ata.key,
992 false
993 ));
994 accounts.push(solana_program::instruction::AccountMeta::new(
995 *self.vault_b_ata.key,
996 false
997 ));
998 accounts.push(solana_program::instruction::AccountMeta::new(
999 *self.tuna_position.key,
1000 false
1001 ));
1002 accounts.push(solana_program::instruction::AccountMeta::new(
1003 *self.tuna_position_mint.key,
1004 true
1005 ));
1006 accounts.push(solana_program::instruction::AccountMeta::new(
1007 *self.tuna_position_ata.key,
1008 false
1009 ));
1010 accounts.push(solana_program::instruction::AccountMeta::new(
1011 *self.tuna_position_ata_a.key,
1012 false
1013 ));
1014 accounts.push(solana_program::instruction::AccountMeta::new(
1015 *self.tuna_position_ata_b.key,
1016 false
1017 ));
1018 accounts.push(solana_program::instruction::AccountMeta::new(
1019 *self.tuna_position_owner_ata_a.key,
1020 false
1021 ));
1022 accounts.push(solana_program::instruction::AccountMeta::new(
1023 *self.tuna_position_owner_ata_b.key,
1024 false
1025 ));
1026 accounts.push(solana_program::instruction::AccountMeta::new(
1027 *self.fee_recipient_ata_a.key,
1028 false
1029 ));
1030 accounts.push(solana_program::instruction::AccountMeta::new(
1031 *self.fee_recipient_ata_b.key,
1032 false
1033 ));
1034 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
1035 *self.pyth_oracle_price_feed_a.key,
1036 false
1037 ));
1038 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
1039 *self.pyth_oracle_price_feed_b.key,
1040 false
1041 ));
1042 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
1043 *self.fusionamm_program.key,
1044 false
1045 ));
1046 accounts.push(solana_program::instruction::AccountMeta::new(
1047 *self.fusion_pool.key,
1048 false
1049 ));
1050 accounts.push(solana_program::instruction::AccountMeta::new(
1051 *self.fusion_position.key,
1052 false
1053 ));
1054 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
1055 *self.metadata_update_auth.key,
1056 false
1057 ));
1058 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
1059 *self.memo_program.key,
1060 false
1061 ));
1062 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
1063 *self.token2022_program.key,
1064 false
1065 ));
1066 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
1067 *self.system_program.key,
1068 false
1069 ));
1070 accounts.push(solana_program::instruction::AccountMeta::new_readonly(
1071 *self.associated_token_program.key,
1072 false
1073 ));
1074 remaining_accounts.iter().for_each(|remaining_account| {
1075 accounts.push(solana_program::instruction::AccountMeta {
1076 pubkey: *remaining_account.0.key,
1077 is_signer: remaining_account.1,
1078 is_writable: remaining_account.2,
1079 })
1080 });
1081 let mut data = borsh::to_vec(&OpenPositionWithLiquidityFusionInstructionData::new()).unwrap();
1082 let mut args = borsh::to_vec(&self.__args).unwrap();
1083 data.append(&mut args);
1084
1085 let instruction = solana_program::instruction::Instruction {
1086 program_id: crate::TUNA_ID,
1087 accounts,
1088 data,
1089 };
1090 let mut account_infos = Vec::with_capacity(31 + remaining_accounts.len());
1091 account_infos.push(self.__program.clone());
1092 account_infos.push(self.authority.clone());
1093 account_infos.push(self.tuna_config.clone());
1094 account_infos.push(self.mint_a.clone());
1095 account_infos.push(self.mint_b.clone());
1096 account_infos.push(self.token_program_a.clone());
1097 account_infos.push(self.token_program_b.clone());
1098 account_infos.push(self.market.clone());
1099 account_infos.push(self.vault_a.clone());
1100 account_infos.push(self.vault_b.clone());
1101 account_infos.push(self.vault_a_ata.clone());
1102 account_infos.push(self.vault_b_ata.clone());
1103 account_infos.push(self.tuna_position.clone());
1104 account_infos.push(self.tuna_position_mint.clone());
1105 account_infos.push(self.tuna_position_ata.clone());
1106 account_infos.push(self.tuna_position_ata_a.clone());
1107 account_infos.push(self.tuna_position_ata_b.clone());
1108 account_infos.push(self.tuna_position_owner_ata_a.clone());
1109 account_infos.push(self.tuna_position_owner_ata_b.clone());
1110 account_infos.push(self.fee_recipient_ata_a.clone());
1111 account_infos.push(self.fee_recipient_ata_b.clone());
1112 account_infos.push(self.pyth_oracle_price_feed_a.clone());
1113 account_infos.push(self.pyth_oracle_price_feed_b.clone());
1114 account_infos.push(self.fusionamm_program.clone());
1115 account_infos.push(self.fusion_pool.clone());
1116 account_infos.push(self.fusion_position.clone());
1117 account_infos.push(self.metadata_update_auth.clone());
1118 account_infos.push(self.memo_program.clone());
1119 account_infos.push(self.token2022_program.clone());
1120 account_infos.push(self.system_program.clone());
1121 account_infos.push(self.associated_token_program.clone());
1122 remaining_accounts.iter().for_each(|remaining_account| account_infos.push(remaining_account.0.clone()));
1123
1124 if signers_seeds.is_empty() {
1125 solana_program::program::invoke(&instruction, &account_infos)
1126 } else {
1127 solana_program::program::invoke_signed(&instruction, &account_infos, signers_seeds)
1128 }
1129 }
1130}
1131
1132#[derive(Clone, Debug)]
1167pub struct OpenPositionWithLiquidityFusionCpiBuilder<'a, 'b> {
1168 instruction: Box<OpenPositionWithLiquidityFusionCpiBuilderInstruction<'a, 'b>>,
1169}
1170
1171impl<'a, 'b> OpenPositionWithLiquidityFusionCpiBuilder<'a, 'b> {
1172 pub fn new(program: &'b solana_program::account_info::AccountInfo<'a>) -> Self {
1173 let instruction = Box::new(OpenPositionWithLiquidityFusionCpiBuilderInstruction {
1174 __program: program,
1175 authority: None,
1176 tuna_config: None,
1177 mint_a: None,
1178 mint_b: None,
1179 token_program_a: None,
1180 token_program_b: None,
1181 market: None,
1182 vault_a: None,
1183 vault_b: None,
1184 vault_a_ata: None,
1185 vault_b_ata: None,
1186 tuna_position: None,
1187 tuna_position_mint: None,
1188 tuna_position_ata: None,
1189 tuna_position_ata_a: None,
1190 tuna_position_ata_b: None,
1191 tuna_position_owner_ata_a: None,
1192 tuna_position_owner_ata_b: None,
1193 fee_recipient_ata_a: None,
1194 fee_recipient_ata_b: None,
1195 pyth_oracle_price_feed_a: None,
1196 pyth_oracle_price_feed_b: None,
1197 fusionamm_program: None,
1198 fusion_pool: None,
1199 fusion_position: None,
1200 metadata_update_auth: None,
1201 memo_program: None,
1202 token2022_program: None,
1203 system_program: None,
1204 associated_token_program: None,
1205 tick_lower_index: None,
1206 tick_upper_index: None,
1207 tick_stop_loss_index: None,
1208 tick_take_profit_index: None,
1209 flags: None,
1210 collateral_a: None,
1211 collateral_b: None,
1212 borrow_a: None,
1213 borrow_b: None,
1214 min_added_amount_a: None,
1215 min_added_amount_b: None,
1216 max_swap_slippage: None,
1217 remaining_accounts_info: None,
1218 __remaining_accounts: Vec::new(),
1219 });
1220 Self { instruction }
1221 }
1222 #[inline(always)]
1226 pub fn authority(&mut self, authority: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1227 self.instruction.authority = Some(authority);
1228 self
1229 }
1230 #[inline(always)]
1231 pub fn tuna_config(&mut self, tuna_config: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1232 self.instruction.tuna_config = Some(tuna_config);
1233 self
1234 }
1235 #[inline(always)]
1236 pub fn mint_a(&mut self, mint_a: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1237 self.instruction.mint_a = Some(mint_a);
1238 self
1239 }
1240 #[inline(always)]
1241 pub fn mint_b(&mut self, mint_b: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1242 self.instruction.mint_b = Some(mint_b);
1243 self
1244 }
1245 #[inline(always)]
1246 pub fn token_program_a(&mut self, token_program_a: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1247 self.instruction.token_program_a = Some(token_program_a);
1248 self
1249 }
1250 #[inline(always)]
1251 pub fn token_program_b(&mut self, token_program_b: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1252 self.instruction.token_program_b = Some(token_program_b);
1253 self
1254 }
1255 #[inline(always)]
1256 pub fn market(&mut self, market: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1257 self.instruction.market = Some(market);
1258 self
1259 }
1260 #[inline(always)]
1261 pub fn vault_a(&mut self, vault_a: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1262 self.instruction.vault_a = Some(vault_a);
1263 self
1264 }
1265 #[inline(always)]
1266 pub fn vault_b(&mut self, vault_b: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1267 self.instruction.vault_b = Some(vault_b);
1268 self
1269 }
1270 #[inline(always)]
1271 pub fn vault_a_ata(&mut self, vault_a_ata: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1272 self.instruction.vault_a_ata = Some(vault_a_ata);
1273 self
1274 }
1275 #[inline(always)]
1276 pub fn vault_b_ata(&mut self, vault_b_ata: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1277 self.instruction.vault_b_ata = Some(vault_b_ata);
1278 self
1279 }
1280 #[inline(always)]
1281 pub fn tuna_position(&mut self, tuna_position: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1282 self.instruction.tuna_position = Some(tuna_position);
1283 self
1284 }
1285 #[inline(always)]
1286 pub fn tuna_position_mint(&mut self, tuna_position_mint: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1287 self.instruction.tuna_position_mint = Some(tuna_position_mint);
1288 self
1289 }
1290 #[inline(always)]
1291 pub fn tuna_position_ata(&mut self, tuna_position_ata: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1292 self.instruction.tuna_position_ata = Some(tuna_position_ata);
1293 self
1294 }
1295 #[inline(always)]
1296 pub fn tuna_position_ata_a(&mut self, tuna_position_ata_a: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1297 self.instruction.tuna_position_ata_a = Some(tuna_position_ata_a);
1298 self
1299 }
1300 #[inline(always)]
1301 pub fn tuna_position_ata_b(&mut self, tuna_position_ata_b: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1302 self.instruction.tuna_position_ata_b = Some(tuna_position_ata_b);
1303 self
1304 }
1305 #[inline(always)]
1306 pub fn tuna_position_owner_ata_a(&mut self, tuna_position_owner_ata_a: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1307 self.instruction.tuna_position_owner_ata_a = Some(tuna_position_owner_ata_a);
1308 self
1309 }
1310 #[inline(always)]
1311 pub fn tuna_position_owner_ata_b(&mut self, tuna_position_owner_ata_b: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1312 self.instruction.tuna_position_owner_ata_b = Some(tuna_position_owner_ata_b);
1313 self
1314 }
1315 #[inline(always)]
1316 pub fn fee_recipient_ata_a(&mut self, fee_recipient_ata_a: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1317 self.instruction.fee_recipient_ata_a = Some(fee_recipient_ata_a);
1318 self
1319 }
1320 #[inline(always)]
1321 pub fn fee_recipient_ata_b(&mut self, fee_recipient_ata_b: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1322 self.instruction.fee_recipient_ata_b = Some(fee_recipient_ata_b);
1323 self
1324 }
1325 #[inline(always)]
1326 pub fn pyth_oracle_price_feed_a(&mut self, pyth_oracle_price_feed_a: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1327 self.instruction.pyth_oracle_price_feed_a = Some(pyth_oracle_price_feed_a);
1328 self
1329 }
1330 #[inline(always)]
1331 pub fn pyth_oracle_price_feed_b(&mut self, pyth_oracle_price_feed_b: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1332 self.instruction.pyth_oracle_price_feed_b = Some(pyth_oracle_price_feed_b);
1333 self
1334 }
1335 #[inline(always)]
1339 pub fn fusionamm_program(&mut self, fusionamm_program: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1340 self.instruction.fusionamm_program = Some(fusionamm_program);
1341 self
1342 }
1343 #[inline(always)]
1344 pub fn fusion_pool(&mut self, fusion_pool: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1345 self.instruction.fusion_pool = Some(fusion_pool);
1346 self
1347 }
1348 #[inline(always)]
1349 pub fn fusion_position(&mut self, fusion_position: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1350 self.instruction.fusion_position = Some(fusion_position);
1351 self
1352 }
1353 #[inline(always)]
1354 pub fn metadata_update_auth(&mut self, metadata_update_auth: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1355 self.instruction.metadata_update_auth = Some(metadata_update_auth);
1356 self
1357 }
1358 #[inline(always)]
1359 pub fn memo_program(&mut self, memo_program: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1360 self.instruction.memo_program = Some(memo_program);
1361 self
1362 }
1363 #[inline(always)]
1367 pub fn token2022_program(&mut self, token2022_program: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1368 self.instruction.token2022_program = Some(token2022_program);
1369 self
1370 }
1371 #[inline(always)]
1372 pub fn system_program(&mut self, system_program: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1373 self.instruction.system_program = Some(system_program);
1374 self
1375 }
1376 #[inline(always)]
1377 pub fn associated_token_program(&mut self, associated_token_program: &'b solana_program::account_info::AccountInfo<'a>) -> &mut Self {
1378 self.instruction.associated_token_program = Some(associated_token_program);
1379 self
1380 }
1381 #[inline(always)]
1382 pub fn tick_lower_index(&mut self, tick_lower_index: i32) -> &mut Self {
1383 self.instruction.tick_lower_index = Some(tick_lower_index);
1384 self
1385 }
1386 #[inline(always)]
1387 pub fn tick_upper_index(&mut self, tick_upper_index: i32) -> &mut Self {
1388 self.instruction.tick_upper_index = Some(tick_upper_index);
1389 self
1390 }
1391 #[inline(always)]
1392 pub fn tick_stop_loss_index(&mut self, tick_stop_loss_index: i32) -> &mut Self {
1393 self.instruction.tick_stop_loss_index = Some(tick_stop_loss_index);
1394 self
1395 }
1396 #[inline(always)]
1397 pub fn tick_take_profit_index(&mut self, tick_take_profit_index: i32) -> &mut Self {
1398 self.instruction.tick_take_profit_index = Some(tick_take_profit_index);
1399 self
1400 }
1401 #[inline(always)]
1402 pub fn flags(&mut self, flags: u32) -> &mut Self {
1403 self.instruction.flags = Some(flags);
1404 self
1405 }
1406 #[inline(always)]
1407 pub fn collateral_a(&mut self, collateral_a: u64) -> &mut Self {
1408 self.instruction.collateral_a = Some(collateral_a);
1409 self
1410 }
1411 #[inline(always)]
1412 pub fn collateral_b(&mut self, collateral_b: u64) -> &mut Self {
1413 self.instruction.collateral_b = Some(collateral_b);
1414 self
1415 }
1416 #[inline(always)]
1417 pub fn borrow_a(&mut self, borrow_a: u64) -> &mut Self {
1418 self.instruction.borrow_a = Some(borrow_a);
1419 self
1420 }
1421 #[inline(always)]
1422 pub fn borrow_b(&mut self, borrow_b: u64) -> &mut Self {
1423 self.instruction.borrow_b = Some(borrow_b);
1424 self
1425 }
1426 #[inline(always)]
1427 pub fn min_added_amount_a(&mut self, min_added_amount_a: u64) -> &mut Self {
1428 self.instruction.min_added_amount_a = Some(min_added_amount_a);
1429 self
1430 }
1431 #[inline(always)]
1432 pub fn min_added_amount_b(&mut self, min_added_amount_b: u64) -> &mut Self {
1433 self.instruction.min_added_amount_b = Some(min_added_amount_b);
1434 self
1435 }
1436 #[inline(always)]
1437 pub fn max_swap_slippage(&mut self, max_swap_slippage: u32) -> &mut Self {
1438 self.instruction.max_swap_slippage = Some(max_swap_slippage);
1439 self
1440 }
1441 #[inline(always)]
1442 pub fn remaining_accounts_info(&mut self, remaining_accounts_info: RemainingAccountsInfo) -> &mut Self {
1443 self.instruction.remaining_accounts_info = Some(remaining_accounts_info);
1444 self
1445 }
1446 #[inline(always)]
1448 pub fn add_remaining_account(&mut self, account: &'b solana_program::account_info::AccountInfo<'a>, is_writable: bool, is_signer: bool) -> &mut Self {
1449 self.instruction.__remaining_accounts.push((account, is_writable, is_signer));
1450 self
1451 }
1452 #[inline(always)]
1457 pub fn add_remaining_accounts(&mut self, accounts: &[(&'b solana_program::account_info::AccountInfo<'a>, bool, bool)]) -> &mut Self {
1458 self.instruction.__remaining_accounts.extend_from_slice(accounts);
1459 self
1460 }
1461 #[inline(always)]
1462 pub fn invoke(&self) -> solana_program::entrypoint::ProgramResult {
1463 self.invoke_signed(&[])
1464 }
1465 #[allow(clippy::clone_on_copy)]
1466 #[allow(clippy::vec_init_then_push)]
1467 pub fn invoke_signed(&self, signers_seeds: &[&[&[u8]]]) -> solana_program::entrypoint::ProgramResult {
1468 let args = OpenPositionWithLiquidityFusionInstructionArgs {
1469 tick_lower_index: self.instruction.tick_lower_index.clone().expect("tick_lower_index is not set"),
1470 tick_upper_index: self.instruction.tick_upper_index.clone().expect("tick_upper_index is not set"),
1471 tick_stop_loss_index: self.instruction.tick_stop_loss_index.clone().expect("tick_stop_loss_index is not set"),
1472 tick_take_profit_index: self.instruction.tick_take_profit_index.clone().expect("tick_take_profit_index is not set"),
1473 flags: self.instruction.flags.clone().expect("flags is not set"),
1474 collateral_a: self.instruction.collateral_a.clone().expect("collateral_a is not set"),
1475 collateral_b: self.instruction.collateral_b.clone().expect("collateral_b is not set"),
1476 borrow_a: self.instruction.borrow_a.clone().expect("borrow_a is not set"),
1477 borrow_b: self.instruction.borrow_b.clone().expect("borrow_b is not set"),
1478 min_added_amount_a: self.instruction.min_added_amount_a.clone().expect("min_added_amount_a is not set"),
1479 min_added_amount_b: self.instruction.min_added_amount_b.clone().expect("min_added_amount_b is not set"),
1480 max_swap_slippage: self.instruction.max_swap_slippage.clone().expect("max_swap_slippage is not set"),
1481 remaining_accounts_info: self.instruction.remaining_accounts_info.clone().expect("remaining_accounts_info is not set"),
1482 };
1483 let instruction = OpenPositionWithLiquidityFusionCpi {
1484 __program: self.instruction.__program,
1485
1486 authority: self.instruction.authority.expect("authority is not set"),
1487
1488 tuna_config: self.instruction.tuna_config.expect("tuna_config is not set"),
1489
1490 mint_a: self.instruction.mint_a.expect("mint_a is not set"),
1491
1492 mint_b: self.instruction.mint_b.expect("mint_b is not set"),
1493
1494 token_program_a: self.instruction.token_program_a.expect("token_program_a is not set"),
1495
1496 token_program_b: self.instruction.token_program_b.expect("token_program_b is not set"),
1497
1498 market: self.instruction.market.expect("market is not set"),
1499
1500 vault_a: self.instruction.vault_a.expect("vault_a is not set"),
1501
1502 vault_b: self.instruction.vault_b.expect("vault_b is not set"),
1503
1504 vault_a_ata: self.instruction.vault_a_ata.expect("vault_a_ata is not set"),
1505
1506 vault_b_ata: self.instruction.vault_b_ata.expect("vault_b_ata is not set"),
1507
1508 tuna_position: self.instruction.tuna_position.expect("tuna_position is not set"),
1509
1510 tuna_position_mint: self.instruction.tuna_position_mint.expect("tuna_position_mint is not set"),
1511
1512 tuna_position_ata: self.instruction.tuna_position_ata.expect("tuna_position_ata is not set"),
1513
1514 tuna_position_ata_a: self.instruction.tuna_position_ata_a.expect("tuna_position_ata_a is not set"),
1515
1516 tuna_position_ata_b: self.instruction.tuna_position_ata_b.expect("tuna_position_ata_b is not set"),
1517
1518 tuna_position_owner_ata_a: self.instruction.tuna_position_owner_ata_a.expect("tuna_position_owner_ata_a is not set"),
1519
1520 tuna_position_owner_ata_b: self.instruction.tuna_position_owner_ata_b.expect("tuna_position_owner_ata_b is not set"),
1521
1522 fee_recipient_ata_a: self.instruction.fee_recipient_ata_a.expect("fee_recipient_ata_a is not set"),
1523
1524 fee_recipient_ata_b: self.instruction.fee_recipient_ata_b.expect("fee_recipient_ata_b is not set"),
1525
1526 pyth_oracle_price_feed_a: self.instruction.pyth_oracle_price_feed_a.expect("pyth_oracle_price_feed_a is not set"),
1527
1528 pyth_oracle_price_feed_b: self.instruction.pyth_oracle_price_feed_b.expect("pyth_oracle_price_feed_b is not set"),
1529
1530 fusionamm_program: self.instruction.fusionamm_program.expect("fusionamm_program is not set"),
1531
1532 fusion_pool: self.instruction.fusion_pool.expect("fusion_pool is not set"),
1533
1534 fusion_position: self.instruction.fusion_position.expect("fusion_position is not set"),
1535
1536 metadata_update_auth: self.instruction.metadata_update_auth.expect("metadata_update_auth is not set"),
1537
1538 memo_program: self.instruction.memo_program.expect("memo_program is not set"),
1539
1540 token2022_program: self.instruction.token2022_program.expect("token2022_program is not set"),
1541
1542 system_program: self.instruction.system_program.expect("system_program is not set"),
1543
1544 associated_token_program: self.instruction.associated_token_program.expect("associated_token_program is not set"),
1545 __args: args,
1546 };
1547 instruction.invoke_signed_with_remaining_accounts(signers_seeds, &self.instruction.__remaining_accounts)
1548 }
1549}
1550
1551#[derive(Clone, Debug)]
1552struct OpenPositionWithLiquidityFusionCpiBuilderInstruction<'a, 'b> {
1553 __program: &'b solana_program::account_info::AccountInfo<'a>,
1554 authority: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1555 tuna_config: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1556 mint_a: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1557 mint_b: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1558 token_program_a: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1559 token_program_b: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1560 market: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1561 vault_a: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1562 vault_b: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1563 vault_a_ata: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1564 vault_b_ata: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1565 tuna_position: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1566 tuna_position_mint: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1567 tuna_position_ata: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1568 tuna_position_ata_a: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1569 tuna_position_ata_b: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1570 tuna_position_owner_ata_a: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1571 tuna_position_owner_ata_b: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1572 fee_recipient_ata_a: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1573 fee_recipient_ata_b: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1574 pyth_oracle_price_feed_a: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1575 pyth_oracle_price_feed_b: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1576 fusionamm_program: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1577 fusion_pool: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1578 fusion_position: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1579 metadata_update_auth: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1580 memo_program: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1581 token2022_program: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1582 system_program: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1583 associated_token_program: Option<&'b solana_program::account_info::AccountInfo<'a>>,
1584 tick_lower_index: Option<i32>,
1585 tick_upper_index: Option<i32>,
1586 tick_stop_loss_index: Option<i32>,
1587 tick_take_profit_index: Option<i32>,
1588 flags: Option<u32>,
1589 collateral_a: Option<u64>,
1590 collateral_b: Option<u64>,
1591 borrow_a: Option<u64>,
1592 borrow_b: Option<u64>,
1593 min_added_amount_a: Option<u64>,
1594 min_added_amount_b: Option<u64>,
1595 max_swap_slippage: Option<u32>,
1596 remaining_accounts_info: Option<RemainingAccountsInfo>,
1597 __remaining_accounts: Vec<(&'b solana_program::account_info::AccountInfo<'a>, bool, bool)>,
1599}
1600