1#![allow(
2 clippy::all,
3 clippy::pedantic,
4 clippy::nursery,
5 clippy::expect_used,
6 clippy::unwrap_used,
7 clippy::indexing_slicing,
8 clippy::allow_attributes,
9 clippy::allow_attributes_without_reason,
10 clippy::mem_forget,
11 unfulfilled_lint_expectations,
12 unexpected_cfgs,
13 unused_imports
14)]
15
16use borsh::BorshDeserialize;
24use borsh::BorshSerialize;
25use solana_address::Address;
26
27pub const CREATE_TOKEN_DISCRIMINATOR: [u8; 8] =
28 [84, 52, 204, 228, 24, 140, 234, 75];
29
30#[derive(Debug)]
32pub struct CreateToken {
33 pub user: solana_address::Address,
34 pub payer: solana_address::Address,
35 pub coin_creator: solana_address::Address,
36 pub global_config: solana_address::Address,
37 pub base_mint: solana_address::Address,
38 pub quote_mint: solana_address::Address,
39 pub bonding_curve: solana_address::Address,
40 pub base_vault: solana_address::Address,
41 pub quote_vault: solana_address::Address,
42 pub creator_fee_config: solana_address::Address,
43 pub nexus_program: solana_address::Address,
44 pub nexus_global_config: solana_address::Address,
45 pub partner: (solana_address::Address, bool),
47 pub partner_config: solana_address::Address,
48 pub nexus_staking_config: solana_address::Address,
49 pub staking_reward_state: solana_address::Address,
50 pub reward_accrual: solana_address::Address,
51 pub staking_vault: solana_address::Address,
52 pub staking_wsol_vault: solana_address::Address,
53 pub wsol_reward_accrual: solana_address::Address,
54 pub pyth_price_feed: solana_address::Address,
55 pub base_token_program: solana_address::Address,
56 pub quote_token_program: solana_address::Address,
57 pub wsol_token_program: solana_address::Address,
58 pub associated_token_program: solana_address::Address,
59 pub system_program: solana_address::Address,
60 pub event_authority: solana_address::Address,
61 pub program: solana_address::Address,
62}
63
64impl CreateToken {
65 pub fn instruction(
66 &self,
67 args: CreateTokenInstructionArgs,
68 ) -> solana_instruction::Instruction {
69 self.instruction_with_remaining_accounts(args, &[])
70 }
71 #[allow(clippy::arithmetic_side_effects)]
72 #[allow(clippy::vec_init_then_push)]
73 pub fn instruction_with_remaining_accounts(
74 &self,
75 args: CreateTokenInstructionArgs,
76 remaining_accounts: &[solana_instruction::AccountMeta],
77 ) -> solana_instruction::Instruction {
78 let mut accounts = Vec::with_capacity(28 + remaining_accounts.len());
79 accounts.push(solana_instruction::AccountMeta::new(self.user, true));
80 accounts.push(solana_instruction::AccountMeta::new(self.payer, true));
81 accounts.push(solana_instruction::AccountMeta::new_readonly(
82 self.coin_creator,
83 false,
84 ));
85 accounts.push(solana_instruction::AccountMeta::new_readonly(
86 self.global_config,
87 false,
88 ));
89 accounts
90 .push(solana_instruction::AccountMeta::new(self.base_mint, true));
91 accounts.push(solana_instruction::AccountMeta::new_readonly(
92 self.quote_mint,
93 false,
94 ));
95 accounts.push(solana_instruction::AccountMeta::new(
96 self.bonding_curve,
97 false,
98 ));
99 accounts
100 .push(solana_instruction::AccountMeta::new(self.base_vault, false));
101 accounts.push(solana_instruction::AccountMeta::new(
102 self.quote_vault,
103 false,
104 ));
105 accounts.push(solana_instruction::AccountMeta::new(
106 self.creator_fee_config,
107 false,
108 ));
109 accounts.push(solana_instruction::AccountMeta::new_readonly(
110 self.nexus_program,
111 false,
112 ));
113 accounts.push(solana_instruction::AccountMeta::new_readonly(
114 self.nexus_global_config,
115 false,
116 ));
117 accounts.push(solana_instruction::AccountMeta::new_readonly(
118 self.partner.0,
119 self.partner.1,
120 ));
121 accounts.push(solana_instruction::AccountMeta::new_readonly(
122 self.partner_config,
123 false,
124 ));
125 accounts.push(solana_instruction::AccountMeta::new_readonly(
126 self.nexus_staking_config,
127 false,
128 ));
129 accounts.push(solana_instruction::AccountMeta::new(
130 self.staking_reward_state,
131 false,
132 ));
133 accounts.push(solana_instruction::AccountMeta::new(
134 self.reward_accrual,
135 false,
136 ));
137 accounts.push(solana_instruction::AccountMeta::new(
138 self.staking_vault,
139 false,
140 ));
141 accounts.push(solana_instruction::AccountMeta::new(
142 self.staking_wsol_vault,
143 false,
144 ));
145 accounts.push(solana_instruction::AccountMeta::new(
146 self.wsol_reward_accrual,
147 false,
148 ));
149 accounts.push(solana_instruction::AccountMeta::new_readonly(
150 self.pyth_price_feed,
151 false,
152 ));
153 accounts.push(solana_instruction::AccountMeta::new_readonly(
154 self.base_token_program,
155 false,
156 ));
157 accounts.push(solana_instruction::AccountMeta::new_readonly(
158 self.quote_token_program,
159 false,
160 ));
161 accounts.push(solana_instruction::AccountMeta::new_readonly(
162 self.wsol_token_program,
163 false,
164 ));
165 accounts.push(solana_instruction::AccountMeta::new_readonly(
166 self.associated_token_program,
167 false,
168 ));
169 accounts.push(solana_instruction::AccountMeta::new_readonly(
170 self.system_program,
171 false,
172 ));
173 accounts.push(solana_instruction::AccountMeta::new_readonly(
174 self.event_authority,
175 false,
176 ));
177 accounts.push(solana_instruction::AccountMeta::new_readonly(
178 self.program,
179 false,
180 ));
181 accounts.extend_from_slice(remaining_accounts);
182 let mut data = CreateTokenInstructionData::new().try_to_vec().unwrap();
183 let mut args = args.try_to_vec().unwrap();
184 data.append(&mut args);
185
186 solana_instruction::Instruction {
187 program_id: crate::launchpad::generated::SEND_LAUNCHPAD_ID,
188 accounts,
189 data,
190 }
191 }
192}
193
194#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
195#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
196#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
197pub struct CreateTokenInstructionData {
198 discriminator: [u8; 8],
199}
200
201impl CreateTokenInstructionData {
202 pub fn new() -> Self {
203 Self {
204 discriminator: [84, 52, 204, 228, 24, 140, 234, 75],
205 }
206 }
207
208 pub(crate) fn try_to_vec(&self) -> Result<Vec<u8>, std::io::Error> {
209 borsh::to_vec(self)
210 }
211}
212
213impl Default for CreateTokenInstructionData {
214 fn default() -> Self {
215 Self::new()
216 }
217}
218
219#[derive(BorshSerialize, BorshDeserialize, Clone, Debug, Eq, PartialEq)]
220#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
221#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
222pub struct CreateTokenInstructionArgs {
223 pub platform_config: Address,
224 pub name: String,
225 pub symbol: String,
226 pub uri: String,
227 pub creator_fee_mode: u8,
228 pub creator_fee_bps: u16,
229 pub dex_creator_fee_bps: u16,
230}
231
232impl CreateTokenInstructionArgs {
233 pub(crate) fn try_to_vec(&self) -> Result<Vec<u8>, std::io::Error> {
234 borsh::to_vec(self)
235 }
236}
237
238#[derive(Clone, Debug)]
271pub struct CreateTokenBuilder {
272 user: solana_address::Address,
273 payer: solana_address::Address,
274 coin_creator: solana_address::Address,
275 base_mint: solana_address::Address,
276 quote_mint: solana_address::Address,
277 bonding_curve: Option<solana_address::Address>,
278 base_vault: Option<solana_address::Address>,
279 quote_vault: Option<solana_address::Address>,
280 creator_fee_config: Option<solana_address::Address>,
281 partner: (solana_address::Address, bool),
282 partner_config: Option<solana_address::Address>,
283 nexus_staking_config: Option<solana_address::Address>,
284 staking_reward_state: Option<solana_address::Address>,
285 reward_accrual: Option<solana_address::Address>,
286 staking_vault: Option<solana_address::Address>,
287 quote_token_program: solana_address::Address,
288 platform_config: Address,
289 name: String,
290 symbol: String,
291 uri: String,
292 creator_fee_mode: u8,
293 creator_fee_bps: u16,
294 dex_creator_fee_bps: u16,
295 __remaining_accounts: Vec<solana_instruction::AccountMeta>,
296}
297
298impl CreateTokenBuilder {
299 pub fn new(
300 user: solana_address::Address,
301 payer: solana_address::Address,
302 coin_creator: solana_address::Address,
303 base_mint: solana_address::Address,
304 quote_mint: solana_address::Address,
305 partner: (solana_address::Address, bool),
306 quote_token_program: solana_address::Address,
307 platform_config: Address,
308 name: String,
309 symbol: String,
310 uri: String,
311 creator_fee_mode: u8,
312 creator_fee_bps: u16,
313 dex_creator_fee_bps: u16,
314 ) -> Self {
315 Self {
316 user,
317 payer,
318 coin_creator,
319 base_mint,
320 quote_mint,
321 bonding_curve: None,
322 base_vault: None,
323 quote_vault: None,
324 creator_fee_config: None,
325 partner,
326 partner_config: None,
327 nexus_staking_config: None,
328 staking_reward_state: None,
329 reward_accrual: None,
330 staking_vault: None,
331 quote_token_program,
332 platform_config,
333 name,
334 symbol,
335 uri,
336 creator_fee_mode,
337 creator_fee_bps,
338 dex_creator_fee_bps,
339 __remaining_accounts: Vec::new(),
340 }
341 }
342 #[inline(always)]
344 pub fn bonding_curve(
345 &mut self,
346 bonding_curve: solana_address::Address,
347 ) -> &mut Self {
348 self.bonding_curve = Some(bonding_curve);
349 self
350 }
351 #[inline(always)]
353 pub fn base_vault(
354 &mut self,
355 base_vault: solana_address::Address,
356 ) -> &mut Self {
357 self.base_vault = Some(base_vault);
358 self
359 }
360 #[inline(always)]
362 pub fn quote_vault(
363 &mut self,
364 quote_vault: solana_address::Address,
365 ) -> &mut Self {
366 self.quote_vault = Some(quote_vault);
367 self
368 }
369 #[inline(always)]
371 pub fn creator_fee_config(
372 &mut self,
373 creator_fee_config: solana_address::Address,
374 ) -> &mut Self {
375 self.creator_fee_config = Some(creator_fee_config);
376 self
377 }
378 #[inline(always)]
380 pub fn partner_config(
381 &mut self,
382 partner_config: solana_address::Address,
383 ) -> &mut Self {
384 self.partner_config = Some(partner_config);
385 self
386 }
387 #[inline(always)]
389 pub fn nexus_staking_config(
390 &mut self,
391 nexus_staking_config: solana_address::Address,
392 ) -> &mut Self {
393 self.nexus_staking_config = Some(nexus_staking_config);
394 self
395 }
396 #[inline(always)]
398 pub fn staking_reward_state(
399 &mut self,
400 staking_reward_state: solana_address::Address,
401 ) -> &mut Self {
402 self.staking_reward_state = Some(staking_reward_state);
403 self
404 }
405 #[inline(always)]
407 pub fn reward_accrual(
408 &mut self,
409 reward_accrual: solana_address::Address,
410 ) -> &mut Self {
411 self.reward_accrual = Some(reward_accrual);
412 self
413 }
414 #[inline(always)]
416 pub fn staking_vault(
417 &mut self,
418 staking_vault: solana_address::Address,
419 ) -> &mut Self {
420 self.staking_vault = Some(staking_vault);
421 self
422 }
423 #[inline(always)]
425 pub fn add_remaining_account(
426 &mut self,
427 account: solana_instruction::AccountMeta,
428 ) -> &mut Self {
429 self.__remaining_accounts.push(account);
430 self
431 }
432 #[inline(always)]
434 pub fn add_remaining_accounts(
435 &mut self,
436 accounts: &[solana_instruction::AccountMeta],
437 ) -> &mut Self {
438 self.__remaining_accounts.extend_from_slice(accounts);
439 self
440 }
441 #[allow(clippy::clone_on_copy)]
442 pub fn instruction(&self) -> solana_instruction::Instruction {
443 let user = self.user;
444 let payer = self.payer;
445 let coin_creator = self.coin_creator;
446 let global_config =
447 crate::launchpad::generated::pdas::GLOBAL_CONFIG_ADDRESS;
448 let base_mint = self.base_mint;
449 let quote_mint = self.quote_mint;
450 let bonding_curve = self.bonding_curve.unwrap_or_else(|| {
451 crate::launchpad::generated::pdas::find_bonding_curve_pda(
452 &self.base_mint,
453 &self.quote_mint,
454 )
455 .0
456 });
457 let base_vault = self.base_vault.unwrap_or_else(|| {
458 solana_address::Address::find_program_address(
459 &[
460 bonding_curve.as_ref(),
461 &[
462 6, 221, 246, 225, 238, 117, 143, 222, 24, 66, 93, 188,
463 228, 108, 205, 218, 182, 26, 252, 77, 131, 185, 13, 39,
464 254, 189, 249, 40, 216, 161, 139, 252,
465 ],
466 self.base_mint.as_ref(),
467 ],
468 &solana_address::address!(
469 "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
470 ),
471 )
472 .0
473 });
474 let quote_token_program = self.quote_token_program;
475 let quote_vault = self.quote_vault.unwrap_or_else(|| {
476 solana_address::Address::find_program_address(
477 &[
478 bonding_curve.as_ref(),
479 self.quote_token_program.as_ref(),
480 self.quote_mint.as_ref(),
481 ],
482 &solana_address::address!(
483 "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
484 ),
485 )
486 .0
487 });
488 let creator_fee_config = self.creator_fee_config.unwrap_or_else(|| {
489 crate::launchpad::generated::pdas::find_creator_fee_config_pda(
490 &self.base_mint,
491 &self.quote_mint,
492 )
493 .0
494 });
495 let nexus_program = solana_address::address!(
496 "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX"
497 );
498 let nexus_global_config = solana_address::address!(
499 "3bycfBeRULfXYqcg3DmiYFBjv6mMVidMuqKdFZJTGdNr"
500 );
501 let partner = self.partner;
502 let partner_config = self.partner_config.unwrap_or_else(|| {
503 solana_address::Address::find_program_address(
504 &[
505 &[112, 97, 114, 116, 110, 101, 114],
506 self.platform_config.clone().as_ref(),
507 self.partner.0.as_ref(),
508 ],
509 &solana_address::address!(
510 "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX"
511 ),
512 )
513 .0
514 });
515 let nexus_staking_config =
516 self.nexus_staking_config.unwrap_or_else(|| {
517 solana_address::Address::find_program_address(
518 &[&[
519 115, 116, 97, 107, 105, 110, 103, 95, 99, 111, 110,
520 102, 105, 103,
521 ]],
522 &solana_address::address!(
523 "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX"
524 ),
525 )
526 .0
527 });
528 let staking_reward_state =
529 self.staking_reward_state.unwrap_or_else(|| {
530 solana_address::Address::find_program_address(
531 &[
532 &[114, 101, 119, 97, 114, 100],
533 nexus_staking_config.as_ref(),
534 self.quote_mint.as_ref(),
535 ],
536 &solana_address::address!(
537 "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX"
538 ),
539 )
540 .0
541 });
542 let reward_accrual = self.reward_accrual.unwrap_or_else(|| {
543 crate::launchpad::generated::pdas::find_reward_accrual_pda(
544 &self.quote_mint,
545 )
546 .0
547 });
548 let staking_vault = self.staking_vault.unwrap_or_else(|| {
549 solana_address::Address::find_program_address(
550 &[
551 nexus_staking_config.as_ref(),
552 self.quote_token_program.as_ref(),
553 self.quote_mint.as_ref(),
554 ],
555 &solana_address::address!(
556 "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
557 ),
558 )
559 .0
560 });
561 let staking_wsol_vault = solana_address::address!(
562 "AyisZJxXz9ywXhMwR3sb3oePxBB6UBvixXycAQCdSgrz"
563 );
564 let wsol_reward_accrual =
565 crate::launchpad::generated::pdas::WSOL_REWARD_ACCRUAL_ADDRESS;
566 let pyth_price_feed = solana_address::address!(
567 "7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE"
568 );
569 let base_token_program = solana_address::address!(
570 "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
571 );
572 let wsol_token_program = solana_address::address!(
573 "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
574 );
575 let associated_token_program = solana_address::address!(
576 "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
577 );
578 let system_program =
579 solana_address::address!("11111111111111111111111111111111");
580 let event_authority =
581 crate::launchpad::generated::pdas::EVENT_AUTHORITY_ADDRESS;
582 let program = solana_address::address!(
583 "5R1uFyEE4oxqkm7hJDqHq6gXaLVF9dxeF3LF4yz1sfLP"
584 );
585 let accounts = CreateToken {
586 user,
587 payer,
588 coin_creator,
589 global_config,
590 base_mint,
591 quote_mint,
592 bonding_curve,
593 base_vault,
594 quote_vault,
595 creator_fee_config,
596 nexus_program,
597 nexus_global_config,
598 partner,
599 partner_config,
600 nexus_staking_config,
601 staking_reward_state,
602 reward_accrual,
603 staking_vault,
604 staking_wsol_vault,
605 wsol_reward_accrual,
606 pyth_price_feed,
607 base_token_program,
608 quote_token_program,
609 wsol_token_program,
610 associated_token_program,
611 system_program,
612 event_authority,
613 program,
614 };
615 let args = CreateTokenInstructionArgs {
616 platform_config: self.platform_config.clone(),
617 name: self.name.clone(),
618 symbol: self.symbol.clone(),
619 uri: self.uri.clone(),
620 creator_fee_mode: self.creator_fee_mode.clone(),
621 creator_fee_bps: self.creator_fee_bps.clone(),
622 dex_creator_fee_bps: self.dex_creator_fee_bps.clone(),
623 };
624
625 accounts.instruction_with_remaining_accounts(
626 args,
627 &self.__remaining_accounts,
628 )
629 }
630}
631
632pub struct CreateTokenCpiAccounts<'a, 'b> {
634 pub user: &'b solana_program::account_info::AccountInfo<'a>,
635 pub payer: &'b solana_program::account_info::AccountInfo<'a>,
636 pub coin_creator: &'b solana_program::account_info::AccountInfo<'a>,
637 pub global_config: &'b solana_program::account_info::AccountInfo<'a>,
638 pub base_mint: &'b solana_program::account_info::AccountInfo<'a>,
639 pub quote_mint: &'b solana_program::account_info::AccountInfo<'a>,
640 pub bonding_curve: &'b solana_program::account_info::AccountInfo<'a>,
641 pub base_vault: &'b solana_program::account_info::AccountInfo<'a>,
642 pub quote_vault: &'b solana_program::account_info::AccountInfo<'a>,
643 pub creator_fee_config: &'b solana_program::account_info::AccountInfo<'a>,
644 pub nexus_program: &'b solana_program::account_info::AccountInfo<'a>,
645 pub nexus_global_config: &'b solana_program::account_info::AccountInfo<'a>,
646 pub partner: (&'b solana_program::account_info::AccountInfo<'a>, bool),
648 pub partner_config: &'b solana_program::account_info::AccountInfo<'a>,
649 pub nexus_staking_config: &'b solana_program::account_info::AccountInfo<'a>,
650 pub staking_reward_state: &'b solana_program::account_info::AccountInfo<'a>,
651 pub reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
652 pub staking_vault: &'b solana_program::account_info::AccountInfo<'a>,
653 pub staking_wsol_vault: &'b solana_program::account_info::AccountInfo<'a>,
654 pub wsol_reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
655 pub pyth_price_feed: &'b solana_program::account_info::AccountInfo<'a>,
656 pub base_token_program: &'b solana_program::account_info::AccountInfo<'a>,
657 pub quote_token_program: &'b solana_program::account_info::AccountInfo<'a>,
658 pub wsol_token_program: &'b solana_program::account_info::AccountInfo<'a>,
659 pub associated_token_program:
660 &'b solana_program::account_info::AccountInfo<'a>,
661 pub system_program: &'b solana_program::account_info::AccountInfo<'a>,
662 pub event_authority: &'b solana_program::account_info::AccountInfo<'a>,
663 pub program: &'b solana_program::account_info::AccountInfo<'a>,
664}
665
666pub struct CreateTokenCpi<'a, 'b> {
668 pub __program: &'b solana_program::account_info::AccountInfo<'a>,
670 pub user: &'b solana_program::account_info::AccountInfo<'a>,
671 pub payer: &'b solana_program::account_info::AccountInfo<'a>,
672 pub coin_creator: &'b solana_program::account_info::AccountInfo<'a>,
673 pub global_config: &'b solana_program::account_info::AccountInfo<'a>,
674 pub base_mint: &'b solana_program::account_info::AccountInfo<'a>,
675 pub quote_mint: &'b solana_program::account_info::AccountInfo<'a>,
676 pub bonding_curve: &'b solana_program::account_info::AccountInfo<'a>,
677 pub base_vault: &'b solana_program::account_info::AccountInfo<'a>,
678 pub quote_vault: &'b solana_program::account_info::AccountInfo<'a>,
679 pub creator_fee_config: &'b solana_program::account_info::AccountInfo<'a>,
680 pub nexus_program: &'b solana_program::account_info::AccountInfo<'a>,
681 pub nexus_global_config: &'b solana_program::account_info::AccountInfo<'a>,
682 pub partner: (&'b solana_program::account_info::AccountInfo<'a>, bool),
684 pub partner_config: &'b solana_program::account_info::AccountInfo<'a>,
685 pub nexus_staking_config: &'b solana_program::account_info::AccountInfo<'a>,
686 pub staking_reward_state: &'b solana_program::account_info::AccountInfo<'a>,
687 pub reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
688 pub staking_vault: &'b solana_program::account_info::AccountInfo<'a>,
689 pub staking_wsol_vault: &'b solana_program::account_info::AccountInfo<'a>,
690 pub wsol_reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
691 pub pyth_price_feed: &'b solana_program::account_info::AccountInfo<'a>,
692 pub base_token_program: &'b solana_program::account_info::AccountInfo<'a>,
693 pub quote_token_program: &'b solana_program::account_info::AccountInfo<'a>,
694 pub wsol_token_program: &'b solana_program::account_info::AccountInfo<'a>,
695 pub associated_token_program:
696 &'b solana_program::account_info::AccountInfo<'a>,
697 pub system_program: &'b solana_program::account_info::AccountInfo<'a>,
698 pub event_authority: &'b solana_program::account_info::AccountInfo<'a>,
699 pub program: &'b solana_program::account_info::AccountInfo<'a>,
700 pub __args: CreateTokenInstructionArgs,
702}
703
704impl<'a, 'b> CreateTokenCpi<'a, 'b> {
705 pub fn new(
706 program: &'b solana_program::account_info::AccountInfo<'a>,
707 accounts: CreateTokenCpiAccounts<'a, 'b>,
708 args: CreateTokenInstructionArgs,
709 ) -> Self {
710 Self {
711 __program: program,
712 user: accounts.user,
713 payer: accounts.payer,
714 coin_creator: accounts.coin_creator,
715 global_config: accounts.global_config,
716 base_mint: accounts.base_mint,
717 quote_mint: accounts.quote_mint,
718 bonding_curve: accounts.bonding_curve,
719 base_vault: accounts.base_vault,
720 quote_vault: accounts.quote_vault,
721 creator_fee_config: accounts.creator_fee_config,
722 nexus_program: accounts.nexus_program,
723 nexus_global_config: accounts.nexus_global_config,
724 partner: accounts.partner,
725 partner_config: accounts.partner_config,
726 nexus_staking_config: accounts.nexus_staking_config,
727 staking_reward_state: accounts.staking_reward_state,
728 reward_accrual: accounts.reward_accrual,
729 staking_vault: accounts.staking_vault,
730 staking_wsol_vault: accounts.staking_wsol_vault,
731 wsol_reward_accrual: accounts.wsol_reward_accrual,
732 pyth_price_feed: accounts.pyth_price_feed,
733 base_token_program: accounts.base_token_program,
734 quote_token_program: accounts.quote_token_program,
735 wsol_token_program: accounts.wsol_token_program,
736 associated_token_program: accounts.associated_token_program,
737 system_program: accounts.system_program,
738 event_authority: accounts.event_authority,
739 program: accounts.program,
740 __args: args,
741 }
742 }
743 #[inline(always)]
744 pub fn invoke(&self) -> solana_program::entrypoint::ProgramResult {
745 self.invoke_signed_with_remaining_accounts(&[], &[])
746 }
747 #[inline(always)]
748 pub fn invoke_with_remaining_accounts(
749 &self,
750 remaining_accounts: &[(
751 &'b solana_program::account_info::AccountInfo<'a>,
752 bool,
753 bool,
754 )],
755 ) -> solana_program::entrypoint::ProgramResult {
756 self.invoke_signed_with_remaining_accounts(&[], remaining_accounts)
757 }
758 #[inline(always)]
759 pub fn invoke_signed(
760 &self,
761 signers_seeds: &[&[&[u8]]],
762 ) -> solana_program::entrypoint::ProgramResult {
763 self.invoke_signed_with_remaining_accounts(signers_seeds, &[])
764 }
765 #[allow(clippy::arithmetic_side_effects)]
766 #[allow(clippy::clone_on_copy)]
767 #[allow(clippy::vec_init_then_push)]
768 pub fn invoke_signed_with_remaining_accounts(
769 &self,
770 signers_seeds: &[&[&[u8]]],
771 remaining_accounts: &[(
772 &'b solana_program::account_info::AccountInfo<'a>,
773 bool,
774 bool,
775 )],
776 ) -> solana_program::entrypoint::ProgramResult {
777 let mut accounts = Vec::with_capacity(28 + remaining_accounts.len());
778 accounts
779 .push(solana_instruction::AccountMeta::new(*self.user.key, true));
780 accounts
781 .push(solana_instruction::AccountMeta::new(*self.payer.key, true));
782 accounts.push(solana_instruction::AccountMeta::new_readonly(
783 *self.coin_creator.key,
784 false,
785 ));
786 accounts.push(solana_instruction::AccountMeta::new_readonly(
787 *self.global_config.key,
788 false,
789 ));
790 accounts.push(solana_instruction::AccountMeta::new(
791 *self.base_mint.key,
792 true,
793 ));
794 accounts.push(solana_instruction::AccountMeta::new_readonly(
795 *self.quote_mint.key,
796 false,
797 ));
798 accounts.push(solana_instruction::AccountMeta::new(
799 *self.bonding_curve.key,
800 false,
801 ));
802 accounts.push(solana_instruction::AccountMeta::new(
803 *self.base_vault.key,
804 false,
805 ));
806 accounts.push(solana_instruction::AccountMeta::new(
807 *self.quote_vault.key,
808 false,
809 ));
810 accounts.push(solana_instruction::AccountMeta::new(
811 *self.creator_fee_config.key,
812 false,
813 ));
814 accounts.push(solana_instruction::AccountMeta::new_readonly(
815 *self.nexus_program.key,
816 false,
817 ));
818 accounts.push(solana_instruction::AccountMeta::new_readonly(
819 *self.nexus_global_config.key,
820 false,
821 ));
822 accounts.push(solana_instruction::AccountMeta::new_readonly(
823 *self.partner.0.key,
824 self.partner.1,
825 ));
826 accounts.push(solana_instruction::AccountMeta::new_readonly(
827 *self.partner_config.key,
828 false,
829 ));
830 accounts.push(solana_instruction::AccountMeta::new_readonly(
831 *self.nexus_staking_config.key,
832 false,
833 ));
834 accounts.push(solana_instruction::AccountMeta::new(
835 *self.staking_reward_state.key,
836 false,
837 ));
838 accounts.push(solana_instruction::AccountMeta::new(
839 *self.reward_accrual.key,
840 false,
841 ));
842 accounts.push(solana_instruction::AccountMeta::new(
843 *self.staking_vault.key,
844 false,
845 ));
846 accounts.push(solana_instruction::AccountMeta::new(
847 *self.staking_wsol_vault.key,
848 false,
849 ));
850 accounts.push(solana_instruction::AccountMeta::new(
851 *self.wsol_reward_accrual.key,
852 false,
853 ));
854 accounts.push(solana_instruction::AccountMeta::new_readonly(
855 *self.pyth_price_feed.key,
856 false,
857 ));
858 accounts.push(solana_instruction::AccountMeta::new_readonly(
859 *self.base_token_program.key,
860 false,
861 ));
862 accounts.push(solana_instruction::AccountMeta::new_readonly(
863 *self.quote_token_program.key,
864 false,
865 ));
866 accounts.push(solana_instruction::AccountMeta::new_readonly(
867 *self.wsol_token_program.key,
868 false,
869 ));
870 accounts.push(solana_instruction::AccountMeta::new_readonly(
871 *self.associated_token_program.key,
872 false,
873 ));
874 accounts.push(solana_instruction::AccountMeta::new_readonly(
875 *self.system_program.key,
876 false,
877 ));
878 accounts.push(solana_instruction::AccountMeta::new_readonly(
879 *self.event_authority.key,
880 false,
881 ));
882 accounts.push(solana_instruction::AccountMeta::new_readonly(
883 *self.program.key,
884 false,
885 ));
886 remaining_accounts.iter().for_each(|remaining_account| {
887 accounts.push(solana_instruction::AccountMeta {
888 pubkey: *remaining_account.0.key,
889 is_writable: remaining_account.1,
890 is_signer: remaining_account.2,
891 })
892 });
893 let mut data = CreateTokenInstructionData::new().try_to_vec().unwrap();
894 let mut args = self.__args.try_to_vec().unwrap();
895 data.append(&mut args);
896
897 let instruction = solana_instruction::Instruction {
898 program_id: crate::launchpad::generated::SEND_LAUNCHPAD_ID,
899 accounts,
900 data,
901 };
902 let mut account_infos =
903 Vec::with_capacity(29 + remaining_accounts.len());
904 account_infos.push(self.__program.clone());
905 account_infos.push(self.user.clone());
906 account_infos.push(self.payer.clone());
907 account_infos.push(self.coin_creator.clone());
908 account_infos.push(self.global_config.clone());
909 account_infos.push(self.base_mint.clone());
910 account_infos.push(self.quote_mint.clone());
911 account_infos.push(self.bonding_curve.clone());
912 account_infos.push(self.base_vault.clone());
913 account_infos.push(self.quote_vault.clone());
914 account_infos.push(self.creator_fee_config.clone());
915 account_infos.push(self.nexus_program.clone());
916 account_infos.push(self.nexus_global_config.clone());
917 account_infos.push(self.partner.0.clone());
918 account_infos.push(self.partner_config.clone());
919 account_infos.push(self.nexus_staking_config.clone());
920 account_infos.push(self.staking_reward_state.clone());
921 account_infos.push(self.reward_accrual.clone());
922 account_infos.push(self.staking_vault.clone());
923 account_infos.push(self.staking_wsol_vault.clone());
924 account_infos.push(self.wsol_reward_accrual.clone());
925 account_infos.push(self.pyth_price_feed.clone());
926 account_infos.push(self.base_token_program.clone());
927 account_infos.push(self.quote_token_program.clone());
928 account_infos.push(self.wsol_token_program.clone());
929 account_infos.push(self.associated_token_program.clone());
930 account_infos.push(self.system_program.clone());
931 account_infos.push(self.event_authority.clone());
932 account_infos.push(self.program.clone());
933 remaining_accounts.iter().for_each(|remaining_account| {
934 account_infos.push(remaining_account.0.clone())
935 });
936
937 if signers_seeds.is_empty() {
938 solana_program::program::invoke(&instruction, &account_infos)
939 } else {
940 solana_program::program::invoke_signed(
941 &instruction,
942 &account_infos,
943 signers_seeds,
944 )
945 }
946 }
947}
948
949#[derive(Clone, Debug)]
982pub struct CreateTokenCpiBuilder<'a, 'b> {
983 instruction: Box<CreateTokenCpiBuilderInstruction<'a, 'b>>,
984}
985
986impl<'a, 'b> CreateTokenCpiBuilder<'a, 'b> {
987 pub fn new(
988 __program: &'b solana_program::account_info::AccountInfo<'a>,
989 user: &'b solana_program::account_info::AccountInfo<'a>,
990 payer: &'b solana_program::account_info::AccountInfo<'a>,
991 coin_creator: &'b solana_program::account_info::AccountInfo<'a>,
992 global_config: &'b solana_program::account_info::AccountInfo<'a>,
993 base_mint: &'b solana_program::account_info::AccountInfo<'a>,
994 quote_mint: &'b solana_program::account_info::AccountInfo<'a>,
995 bonding_curve: &'b solana_program::account_info::AccountInfo<'a>,
996 base_vault: &'b solana_program::account_info::AccountInfo<'a>,
997 quote_vault: &'b solana_program::account_info::AccountInfo<'a>,
998 creator_fee_config: &'b solana_program::account_info::AccountInfo<'a>,
999 nexus_program: &'b solana_program::account_info::AccountInfo<'a>,
1000 nexus_global_config: &'b solana_program::account_info::AccountInfo<'a>,
1001 partner: (&'b solana_program::account_info::AccountInfo<'a>, bool),
1002 partner_config: &'b solana_program::account_info::AccountInfo<'a>,
1003 nexus_staking_config: &'b solana_program::account_info::AccountInfo<'a>,
1004 staking_reward_state: &'b solana_program::account_info::AccountInfo<'a>,
1005 reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
1006 staking_vault: &'b solana_program::account_info::AccountInfo<'a>,
1007 staking_wsol_vault: &'b solana_program::account_info::AccountInfo<'a>,
1008 wsol_reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
1009 pyth_price_feed: &'b solana_program::account_info::AccountInfo<'a>,
1010 base_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1011 quote_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1012 wsol_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1013 associated_token_program: &'b solana_program::account_info::AccountInfo<
1014 'a,
1015 >,
1016 system_program: &'b solana_program::account_info::AccountInfo<'a>,
1017 event_authority: &'b solana_program::account_info::AccountInfo<'a>,
1018 program: &'b solana_program::account_info::AccountInfo<'a>,
1019 platform_config: Address,
1020 name: String,
1021 symbol: String,
1022 uri: String,
1023 creator_fee_mode: u8,
1024 creator_fee_bps: u16,
1025 dex_creator_fee_bps: u16,
1026 ) -> Self {
1027 let instruction = Box::new(CreateTokenCpiBuilderInstruction {
1028 __program,
1029 user,
1030 payer,
1031 coin_creator,
1032 global_config,
1033 base_mint,
1034 quote_mint,
1035 bonding_curve,
1036 base_vault,
1037 quote_vault,
1038 creator_fee_config,
1039 nexus_program,
1040 nexus_global_config,
1041 partner,
1042 partner_config,
1043 nexus_staking_config,
1044 staking_reward_state,
1045 reward_accrual,
1046 staking_vault,
1047 staking_wsol_vault,
1048 wsol_reward_accrual,
1049 pyth_price_feed,
1050 base_token_program,
1051 quote_token_program,
1052 wsol_token_program,
1053 associated_token_program,
1054 system_program,
1055 event_authority,
1056 program,
1057 platform_config,
1058 name,
1059 symbol,
1060 uri,
1061 creator_fee_mode,
1062 creator_fee_bps,
1063 dex_creator_fee_bps,
1064 __remaining_accounts: Vec::new(),
1065 });
1066 Self { instruction }
1067 }
1068 #[inline(always)]
1070 pub fn add_remaining_account(
1071 &mut self,
1072 account: &'b solana_program::account_info::AccountInfo<'a>,
1073 is_writable: bool,
1074 is_signer: bool,
1075 ) -> &mut Self {
1076 self.instruction.__remaining_accounts.push((
1077 account,
1078 is_writable,
1079 is_signer,
1080 ));
1081 self
1082 }
1083 #[inline(always)]
1088 pub fn add_remaining_accounts(
1089 &mut self,
1090 accounts: &[(
1091 &'b solana_program::account_info::AccountInfo<'a>,
1092 bool,
1093 bool,
1094 )],
1095 ) -> &mut Self {
1096 self.instruction
1097 .__remaining_accounts
1098 .extend_from_slice(accounts);
1099 self
1100 }
1101 #[inline(always)]
1102 pub fn invoke(&self) -> solana_program::entrypoint::ProgramResult {
1103 self.invoke_signed(&[])
1104 }
1105 #[allow(clippy::clone_on_copy)]
1106 #[allow(clippy::vec_init_then_push)]
1107 pub fn invoke_signed(
1108 &self,
1109 signers_seeds: &[&[&[u8]]],
1110 ) -> solana_program::entrypoint::ProgramResult {
1111 let args = CreateTokenInstructionArgs {
1112 platform_config: self.instruction.platform_config.clone(),
1113 name: self.instruction.name.clone(),
1114 symbol: self.instruction.symbol.clone(),
1115 uri: self.instruction.uri.clone(),
1116 creator_fee_mode: self.instruction.creator_fee_mode.clone(),
1117 creator_fee_bps: self.instruction.creator_fee_bps.clone(),
1118 dex_creator_fee_bps: self.instruction.dex_creator_fee_bps.clone(),
1119 };
1120 let instruction = CreateTokenCpi {
1121 __program: self.instruction.__program,
1122 user: self.instruction.user,
1123 payer: self.instruction.payer,
1124 coin_creator: self.instruction.coin_creator,
1125 global_config: self.instruction.global_config,
1126 base_mint: self.instruction.base_mint,
1127 quote_mint: self.instruction.quote_mint,
1128 bonding_curve: self.instruction.bonding_curve,
1129 base_vault: self.instruction.base_vault,
1130 quote_vault: self.instruction.quote_vault,
1131 creator_fee_config: self.instruction.creator_fee_config,
1132 nexus_program: self.instruction.nexus_program,
1133 nexus_global_config: self.instruction.nexus_global_config,
1134 partner: self.instruction.partner,
1135 partner_config: self.instruction.partner_config,
1136 nexus_staking_config: self.instruction.nexus_staking_config,
1137 staking_reward_state: self.instruction.staking_reward_state,
1138 reward_accrual: self.instruction.reward_accrual,
1139 staking_vault: self.instruction.staking_vault,
1140 staking_wsol_vault: self.instruction.staking_wsol_vault,
1141 wsol_reward_accrual: self.instruction.wsol_reward_accrual,
1142 pyth_price_feed: self.instruction.pyth_price_feed,
1143 base_token_program: self.instruction.base_token_program,
1144 quote_token_program: self.instruction.quote_token_program,
1145 wsol_token_program: self.instruction.wsol_token_program,
1146 associated_token_program: self.instruction.associated_token_program,
1147 system_program: self.instruction.system_program,
1148 event_authority: self.instruction.event_authority,
1149 program: self.instruction.program,
1150 __args: args,
1151 };
1152 instruction.invoke_signed_with_remaining_accounts(
1153 signers_seeds,
1154 &self.instruction.__remaining_accounts,
1155 )
1156 }
1157}
1158
1159#[derive(Clone, Debug)]
1160struct CreateTokenCpiBuilderInstruction<'a, 'b> {
1161 __program: &'b solana_program::account_info::AccountInfo<'a>,
1162 user: &'b solana_program::account_info::AccountInfo<'a>,
1163 payer: &'b solana_program::account_info::AccountInfo<'a>,
1164 coin_creator: &'b solana_program::account_info::AccountInfo<'a>,
1165 global_config: &'b solana_program::account_info::AccountInfo<'a>,
1166 base_mint: &'b solana_program::account_info::AccountInfo<'a>,
1167 quote_mint: &'b solana_program::account_info::AccountInfo<'a>,
1168 bonding_curve: &'b solana_program::account_info::AccountInfo<'a>,
1169 base_vault: &'b solana_program::account_info::AccountInfo<'a>,
1170 quote_vault: &'b solana_program::account_info::AccountInfo<'a>,
1171 creator_fee_config: &'b solana_program::account_info::AccountInfo<'a>,
1172 nexus_program: &'b solana_program::account_info::AccountInfo<'a>,
1173 nexus_global_config: &'b solana_program::account_info::AccountInfo<'a>,
1174 partner: (&'b solana_program::account_info::AccountInfo<'a>, bool),
1175 partner_config: &'b solana_program::account_info::AccountInfo<'a>,
1176 nexus_staking_config: &'b solana_program::account_info::AccountInfo<'a>,
1177 staking_reward_state: &'b solana_program::account_info::AccountInfo<'a>,
1178 reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
1179 staking_vault: &'b solana_program::account_info::AccountInfo<'a>,
1180 staking_wsol_vault: &'b solana_program::account_info::AccountInfo<'a>,
1181 wsol_reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
1182 pyth_price_feed: &'b solana_program::account_info::AccountInfo<'a>,
1183 base_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1184 quote_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1185 wsol_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1186 associated_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1187 system_program: &'b solana_program::account_info::AccountInfo<'a>,
1188 event_authority: &'b solana_program::account_info::AccountInfo<'a>,
1189 program: &'b solana_program::account_info::AccountInfo<'a>,
1190 platform_config: Address,
1191 name: String,
1192 symbol: String,
1193 uri: String,
1194 creator_fee_mode: u8,
1195 creator_fee_bps: u16,
1196 dex_creator_fee_bps: u16,
1197 __remaining_accounts: Vec<(
1199 &'b solana_program::account_info::AccountInfo<'a>,
1200 bool,
1201 bool,
1202 )>,
1203}