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 creator_platform: String,
225 pub creator_id: String,
226 pub creator_hash: Address,
227 pub name: String,
228 pub symbol: String,
229 pub uri: String,
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 creator_platform: String,
290 creator_id: String,
291 creator_hash: Address,
292 name: String,
293 symbol: String,
294 uri: String,
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 creator_platform: String,
309 creator_id: String,
310 creator_hash: Address,
311 name: String,
312 symbol: String,
313 uri: String,
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 creator_platform,
334 creator_id,
335 creator_hash,
336 name,
337 symbol,
338 uri,
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 solana_address::Address::find_program_address(
490 &[
491 &[
492 99, 114, 101, 97, 116, 111, 114, 95, 102, 101, 101, 95,
493 98, 97, 108, 97, 110, 99, 101,
494 ],
495 self.creator_hash.clone().as_ref(),
496 self.quote_mint.as_ref(),
497 ],
498 &solana_address::address!(
499 "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX"
500 ),
501 )
502 .0
503 });
504 let nexus_program = solana_address::address!(
505 "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX"
506 );
507 let nexus_global_config = solana_address::address!(
508 "3bycfBeRULfXYqcg3DmiYFBjv6mMVidMuqKdFZJTGdNr"
509 );
510 let partner = self.partner;
511 let partner_config = self.partner_config.unwrap_or_else(|| {
512 solana_address::Address::find_program_address(
513 &[
514 &[112, 97, 114, 116, 110, 101, 114],
515 self.platform_config.clone().as_ref(),
516 self.partner.0.as_ref(),
517 ],
518 &solana_address::address!(
519 "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX"
520 ),
521 )
522 .0
523 });
524 let nexus_staking_config =
525 self.nexus_staking_config.unwrap_or_else(|| {
526 solana_address::Address::find_program_address(
527 &[&[
528 115, 116, 97, 107, 105, 110, 103, 95, 99, 111, 110,
529 102, 105, 103,
530 ]],
531 &solana_address::address!(
532 "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX"
533 ),
534 )
535 .0
536 });
537 let staking_reward_state =
538 self.staking_reward_state.unwrap_or_else(|| {
539 solana_address::Address::find_program_address(
540 &[
541 &[114, 101, 119, 97, 114, 100],
542 nexus_staking_config.as_ref(),
543 self.quote_mint.as_ref(),
544 ],
545 &solana_address::address!(
546 "7rrCurqdWFesbzwtYPo95fM8waTtVXgXwCom45x1sfNX"
547 ),
548 )
549 .0
550 });
551 let reward_accrual = self.reward_accrual.unwrap_or_else(|| {
552 crate::launchpad::generated::pdas::find_reward_accrual_pda(
553 &self.quote_mint,
554 )
555 .0
556 });
557 let staking_vault = self.staking_vault.unwrap_or_else(|| {
558 solana_address::Address::find_program_address(
559 &[
560 nexus_staking_config.as_ref(),
561 self.quote_token_program.as_ref(),
562 self.quote_mint.as_ref(),
563 ],
564 &solana_address::address!(
565 "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
566 ),
567 )
568 .0
569 });
570 let staking_wsol_vault = solana_address::address!(
571 "AyisZJxXz9ywXhMwR3sb3oePxBB6UBvixXycAQCdSgrz"
572 );
573 let wsol_reward_accrual =
574 crate::launchpad::generated::pdas::WSOL_REWARD_ACCRUAL_ADDRESS;
575 let pyth_price_feed = solana_address::address!(
576 "7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE"
577 );
578 let base_token_program = solana_address::address!(
579 "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
580 );
581 let wsol_token_program = solana_address::address!(
582 "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
583 );
584 let associated_token_program = solana_address::address!(
585 "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
586 );
587 let system_program =
588 solana_address::address!("11111111111111111111111111111111");
589 let event_authority =
590 crate::launchpad::generated::pdas::EVENT_AUTHORITY_ADDRESS;
591 let program = solana_address::address!(
592 "5R1uFyEE4oxqkm7hJDqHq6gXaLVF9dxeF3LF4yz1sfLP"
593 );
594 let accounts = CreateToken {
595 user,
596 payer,
597 coin_creator,
598 global_config,
599 base_mint,
600 quote_mint,
601 bonding_curve,
602 base_vault,
603 quote_vault,
604 creator_fee_config,
605 nexus_program,
606 nexus_global_config,
607 partner,
608 partner_config,
609 nexus_staking_config,
610 staking_reward_state,
611 reward_accrual,
612 staking_vault,
613 staking_wsol_vault,
614 wsol_reward_accrual,
615 pyth_price_feed,
616 base_token_program,
617 quote_token_program,
618 wsol_token_program,
619 associated_token_program,
620 system_program,
621 event_authority,
622 program,
623 };
624 let args = CreateTokenInstructionArgs {
625 platform_config: self.platform_config.clone(),
626 creator_platform: self.creator_platform.clone(),
627 creator_id: self.creator_id.clone(),
628 creator_hash: self.creator_hash.clone(),
629 name: self.name.clone(),
630 symbol: self.symbol.clone(),
631 uri: self.uri.clone(),
632 };
633
634 accounts.instruction_with_remaining_accounts(
635 args,
636 &self.__remaining_accounts,
637 )
638 }
639}
640
641pub struct CreateTokenCpiAccounts<'a, 'b> {
643 pub user: &'b solana_program::account_info::AccountInfo<'a>,
644 pub payer: &'b solana_program::account_info::AccountInfo<'a>,
645 pub coin_creator: &'b solana_program::account_info::AccountInfo<'a>,
646 pub global_config: &'b solana_program::account_info::AccountInfo<'a>,
647 pub base_mint: &'b solana_program::account_info::AccountInfo<'a>,
648 pub quote_mint: &'b solana_program::account_info::AccountInfo<'a>,
649 pub bonding_curve: &'b solana_program::account_info::AccountInfo<'a>,
650 pub base_vault: &'b solana_program::account_info::AccountInfo<'a>,
651 pub quote_vault: &'b solana_program::account_info::AccountInfo<'a>,
652 pub creator_fee_config: &'b solana_program::account_info::AccountInfo<'a>,
653 pub nexus_program: &'b solana_program::account_info::AccountInfo<'a>,
654 pub nexus_global_config: &'b solana_program::account_info::AccountInfo<'a>,
655 pub partner: (&'b solana_program::account_info::AccountInfo<'a>, bool),
657 pub partner_config: &'b solana_program::account_info::AccountInfo<'a>,
658 pub nexus_staking_config: &'b solana_program::account_info::AccountInfo<'a>,
659 pub staking_reward_state: &'b solana_program::account_info::AccountInfo<'a>,
660 pub reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
661 pub staking_vault: &'b solana_program::account_info::AccountInfo<'a>,
662 pub staking_wsol_vault: &'b solana_program::account_info::AccountInfo<'a>,
663 pub wsol_reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
664 pub pyth_price_feed: &'b solana_program::account_info::AccountInfo<'a>,
665 pub base_token_program: &'b solana_program::account_info::AccountInfo<'a>,
666 pub quote_token_program: &'b solana_program::account_info::AccountInfo<'a>,
667 pub wsol_token_program: &'b solana_program::account_info::AccountInfo<'a>,
668 pub associated_token_program:
669 &'b solana_program::account_info::AccountInfo<'a>,
670 pub system_program: &'b solana_program::account_info::AccountInfo<'a>,
671 pub event_authority: &'b solana_program::account_info::AccountInfo<'a>,
672 pub program: &'b solana_program::account_info::AccountInfo<'a>,
673}
674
675pub struct CreateTokenCpi<'a, 'b> {
677 pub __program: &'b solana_program::account_info::AccountInfo<'a>,
679 pub user: &'b solana_program::account_info::AccountInfo<'a>,
680 pub payer: &'b solana_program::account_info::AccountInfo<'a>,
681 pub coin_creator: &'b solana_program::account_info::AccountInfo<'a>,
682 pub global_config: &'b solana_program::account_info::AccountInfo<'a>,
683 pub base_mint: &'b solana_program::account_info::AccountInfo<'a>,
684 pub quote_mint: &'b solana_program::account_info::AccountInfo<'a>,
685 pub bonding_curve: &'b solana_program::account_info::AccountInfo<'a>,
686 pub base_vault: &'b solana_program::account_info::AccountInfo<'a>,
687 pub quote_vault: &'b solana_program::account_info::AccountInfo<'a>,
688 pub creator_fee_config: &'b solana_program::account_info::AccountInfo<'a>,
689 pub nexus_program: &'b solana_program::account_info::AccountInfo<'a>,
690 pub nexus_global_config: &'b solana_program::account_info::AccountInfo<'a>,
691 pub partner: (&'b solana_program::account_info::AccountInfo<'a>, bool),
693 pub partner_config: &'b solana_program::account_info::AccountInfo<'a>,
694 pub nexus_staking_config: &'b solana_program::account_info::AccountInfo<'a>,
695 pub staking_reward_state: &'b solana_program::account_info::AccountInfo<'a>,
696 pub reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
697 pub staking_vault: &'b solana_program::account_info::AccountInfo<'a>,
698 pub staking_wsol_vault: &'b solana_program::account_info::AccountInfo<'a>,
699 pub wsol_reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
700 pub pyth_price_feed: &'b solana_program::account_info::AccountInfo<'a>,
701 pub base_token_program: &'b solana_program::account_info::AccountInfo<'a>,
702 pub quote_token_program: &'b solana_program::account_info::AccountInfo<'a>,
703 pub wsol_token_program: &'b solana_program::account_info::AccountInfo<'a>,
704 pub associated_token_program:
705 &'b solana_program::account_info::AccountInfo<'a>,
706 pub system_program: &'b solana_program::account_info::AccountInfo<'a>,
707 pub event_authority: &'b solana_program::account_info::AccountInfo<'a>,
708 pub program: &'b solana_program::account_info::AccountInfo<'a>,
709 pub __args: CreateTokenInstructionArgs,
711}
712
713impl<'a, 'b> CreateTokenCpi<'a, 'b> {
714 pub fn new(
715 program: &'b solana_program::account_info::AccountInfo<'a>,
716 accounts: CreateTokenCpiAccounts<'a, 'b>,
717 args: CreateTokenInstructionArgs,
718 ) -> Self {
719 Self {
720 __program: program,
721 user: accounts.user,
722 payer: accounts.payer,
723 coin_creator: accounts.coin_creator,
724 global_config: accounts.global_config,
725 base_mint: accounts.base_mint,
726 quote_mint: accounts.quote_mint,
727 bonding_curve: accounts.bonding_curve,
728 base_vault: accounts.base_vault,
729 quote_vault: accounts.quote_vault,
730 creator_fee_config: accounts.creator_fee_config,
731 nexus_program: accounts.nexus_program,
732 nexus_global_config: accounts.nexus_global_config,
733 partner: accounts.partner,
734 partner_config: accounts.partner_config,
735 nexus_staking_config: accounts.nexus_staking_config,
736 staking_reward_state: accounts.staking_reward_state,
737 reward_accrual: accounts.reward_accrual,
738 staking_vault: accounts.staking_vault,
739 staking_wsol_vault: accounts.staking_wsol_vault,
740 wsol_reward_accrual: accounts.wsol_reward_accrual,
741 pyth_price_feed: accounts.pyth_price_feed,
742 base_token_program: accounts.base_token_program,
743 quote_token_program: accounts.quote_token_program,
744 wsol_token_program: accounts.wsol_token_program,
745 associated_token_program: accounts.associated_token_program,
746 system_program: accounts.system_program,
747 event_authority: accounts.event_authority,
748 program: accounts.program,
749 __args: args,
750 }
751 }
752 #[inline(always)]
753 pub fn invoke(&self) -> solana_program::entrypoint::ProgramResult {
754 self.invoke_signed_with_remaining_accounts(&[], &[])
755 }
756 #[inline(always)]
757 pub fn invoke_with_remaining_accounts(
758 &self,
759 remaining_accounts: &[(
760 &'b solana_program::account_info::AccountInfo<'a>,
761 bool,
762 bool,
763 )],
764 ) -> solana_program::entrypoint::ProgramResult {
765 self.invoke_signed_with_remaining_accounts(&[], remaining_accounts)
766 }
767 #[inline(always)]
768 pub fn invoke_signed(
769 &self,
770 signers_seeds: &[&[&[u8]]],
771 ) -> solana_program::entrypoint::ProgramResult {
772 self.invoke_signed_with_remaining_accounts(signers_seeds, &[])
773 }
774 #[allow(clippy::arithmetic_side_effects)]
775 #[allow(clippy::clone_on_copy)]
776 #[allow(clippy::vec_init_then_push)]
777 pub fn invoke_signed_with_remaining_accounts(
778 &self,
779 signers_seeds: &[&[&[u8]]],
780 remaining_accounts: &[(
781 &'b solana_program::account_info::AccountInfo<'a>,
782 bool,
783 bool,
784 )],
785 ) -> solana_program::entrypoint::ProgramResult {
786 let mut accounts = Vec::with_capacity(28 + remaining_accounts.len());
787 accounts
788 .push(solana_instruction::AccountMeta::new(*self.user.key, true));
789 accounts
790 .push(solana_instruction::AccountMeta::new(*self.payer.key, true));
791 accounts.push(solana_instruction::AccountMeta::new_readonly(
792 *self.coin_creator.key,
793 false,
794 ));
795 accounts.push(solana_instruction::AccountMeta::new_readonly(
796 *self.global_config.key,
797 false,
798 ));
799 accounts.push(solana_instruction::AccountMeta::new(
800 *self.base_mint.key,
801 true,
802 ));
803 accounts.push(solana_instruction::AccountMeta::new_readonly(
804 *self.quote_mint.key,
805 false,
806 ));
807 accounts.push(solana_instruction::AccountMeta::new(
808 *self.bonding_curve.key,
809 false,
810 ));
811 accounts.push(solana_instruction::AccountMeta::new(
812 *self.base_vault.key,
813 false,
814 ));
815 accounts.push(solana_instruction::AccountMeta::new(
816 *self.quote_vault.key,
817 false,
818 ));
819 accounts.push(solana_instruction::AccountMeta::new(
820 *self.creator_fee_config.key,
821 false,
822 ));
823 accounts.push(solana_instruction::AccountMeta::new_readonly(
824 *self.nexus_program.key,
825 false,
826 ));
827 accounts.push(solana_instruction::AccountMeta::new_readonly(
828 *self.nexus_global_config.key,
829 false,
830 ));
831 accounts.push(solana_instruction::AccountMeta::new_readonly(
832 *self.partner.0.key,
833 self.partner.1,
834 ));
835 accounts.push(solana_instruction::AccountMeta::new_readonly(
836 *self.partner_config.key,
837 false,
838 ));
839 accounts.push(solana_instruction::AccountMeta::new_readonly(
840 *self.nexus_staking_config.key,
841 false,
842 ));
843 accounts.push(solana_instruction::AccountMeta::new(
844 *self.staking_reward_state.key,
845 false,
846 ));
847 accounts.push(solana_instruction::AccountMeta::new(
848 *self.reward_accrual.key,
849 false,
850 ));
851 accounts.push(solana_instruction::AccountMeta::new(
852 *self.staking_vault.key,
853 false,
854 ));
855 accounts.push(solana_instruction::AccountMeta::new(
856 *self.staking_wsol_vault.key,
857 false,
858 ));
859 accounts.push(solana_instruction::AccountMeta::new(
860 *self.wsol_reward_accrual.key,
861 false,
862 ));
863 accounts.push(solana_instruction::AccountMeta::new_readonly(
864 *self.pyth_price_feed.key,
865 false,
866 ));
867 accounts.push(solana_instruction::AccountMeta::new_readonly(
868 *self.base_token_program.key,
869 false,
870 ));
871 accounts.push(solana_instruction::AccountMeta::new_readonly(
872 *self.quote_token_program.key,
873 false,
874 ));
875 accounts.push(solana_instruction::AccountMeta::new_readonly(
876 *self.wsol_token_program.key,
877 false,
878 ));
879 accounts.push(solana_instruction::AccountMeta::new_readonly(
880 *self.associated_token_program.key,
881 false,
882 ));
883 accounts.push(solana_instruction::AccountMeta::new_readonly(
884 *self.system_program.key,
885 false,
886 ));
887 accounts.push(solana_instruction::AccountMeta::new_readonly(
888 *self.event_authority.key,
889 false,
890 ));
891 accounts.push(solana_instruction::AccountMeta::new_readonly(
892 *self.program.key,
893 false,
894 ));
895 remaining_accounts.iter().for_each(|remaining_account| {
896 accounts.push(solana_instruction::AccountMeta {
897 pubkey: *remaining_account.0.key,
898 is_writable: remaining_account.1,
899 is_signer: remaining_account.2,
900 })
901 });
902 let mut data = CreateTokenInstructionData::new().try_to_vec().unwrap();
903 let mut args = self.__args.try_to_vec().unwrap();
904 data.append(&mut args);
905
906 let instruction = solana_instruction::Instruction {
907 program_id: crate::launchpad::generated::SEND_LAUNCHPAD_ID,
908 accounts,
909 data,
910 };
911 let mut account_infos =
912 Vec::with_capacity(29 + remaining_accounts.len());
913 account_infos.push(self.__program.clone());
914 account_infos.push(self.user.clone());
915 account_infos.push(self.payer.clone());
916 account_infos.push(self.coin_creator.clone());
917 account_infos.push(self.global_config.clone());
918 account_infos.push(self.base_mint.clone());
919 account_infos.push(self.quote_mint.clone());
920 account_infos.push(self.bonding_curve.clone());
921 account_infos.push(self.base_vault.clone());
922 account_infos.push(self.quote_vault.clone());
923 account_infos.push(self.creator_fee_config.clone());
924 account_infos.push(self.nexus_program.clone());
925 account_infos.push(self.nexus_global_config.clone());
926 account_infos.push(self.partner.0.clone());
927 account_infos.push(self.partner_config.clone());
928 account_infos.push(self.nexus_staking_config.clone());
929 account_infos.push(self.staking_reward_state.clone());
930 account_infos.push(self.reward_accrual.clone());
931 account_infos.push(self.staking_vault.clone());
932 account_infos.push(self.staking_wsol_vault.clone());
933 account_infos.push(self.wsol_reward_accrual.clone());
934 account_infos.push(self.pyth_price_feed.clone());
935 account_infos.push(self.base_token_program.clone());
936 account_infos.push(self.quote_token_program.clone());
937 account_infos.push(self.wsol_token_program.clone());
938 account_infos.push(self.associated_token_program.clone());
939 account_infos.push(self.system_program.clone());
940 account_infos.push(self.event_authority.clone());
941 account_infos.push(self.program.clone());
942 remaining_accounts.iter().for_each(|remaining_account| {
943 account_infos.push(remaining_account.0.clone())
944 });
945
946 if signers_seeds.is_empty() {
947 solana_program::program::invoke(&instruction, &account_infos)
948 } else {
949 solana_program::program::invoke_signed(
950 &instruction,
951 &account_infos,
952 signers_seeds,
953 )
954 }
955 }
956}
957
958#[derive(Clone, Debug)]
991pub struct CreateTokenCpiBuilder<'a, 'b> {
992 instruction: Box<CreateTokenCpiBuilderInstruction<'a, 'b>>,
993}
994
995impl<'a, 'b> CreateTokenCpiBuilder<'a, 'b> {
996 pub fn new(
997 __program: &'b solana_program::account_info::AccountInfo<'a>,
998 user: &'b solana_program::account_info::AccountInfo<'a>,
999 payer: &'b solana_program::account_info::AccountInfo<'a>,
1000 coin_creator: &'b solana_program::account_info::AccountInfo<'a>,
1001 global_config: &'b solana_program::account_info::AccountInfo<'a>,
1002 base_mint: &'b solana_program::account_info::AccountInfo<'a>,
1003 quote_mint: &'b solana_program::account_info::AccountInfo<'a>,
1004 bonding_curve: &'b solana_program::account_info::AccountInfo<'a>,
1005 base_vault: &'b solana_program::account_info::AccountInfo<'a>,
1006 quote_vault: &'b solana_program::account_info::AccountInfo<'a>,
1007 creator_fee_config: &'b solana_program::account_info::AccountInfo<'a>,
1008 nexus_program: &'b solana_program::account_info::AccountInfo<'a>,
1009 nexus_global_config: &'b solana_program::account_info::AccountInfo<'a>,
1010 partner: (&'b solana_program::account_info::AccountInfo<'a>, bool),
1011 partner_config: &'b solana_program::account_info::AccountInfo<'a>,
1012 nexus_staking_config: &'b solana_program::account_info::AccountInfo<'a>,
1013 staking_reward_state: &'b solana_program::account_info::AccountInfo<'a>,
1014 reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
1015 staking_vault: &'b solana_program::account_info::AccountInfo<'a>,
1016 staking_wsol_vault: &'b solana_program::account_info::AccountInfo<'a>,
1017 wsol_reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
1018 pyth_price_feed: &'b solana_program::account_info::AccountInfo<'a>,
1019 base_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1020 quote_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1021 wsol_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1022 associated_token_program: &'b solana_program::account_info::AccountInfo<
1023 'a,
1024 >,
1025 system_program: &'b solana_program::account_info::AccountInfo<'a>,
1026 event_authority: &'b solana_program::account_info::AccountInfo<'a>,
1027 program: &'b solana_program::account_info::AccountInfo<'a>,
1028 platform_config: Address,
1029 creator_platform: String,
1030 creator_id: String,
1031 creator_hash: Address,
1032 name: String,
1033 symbol: String,
1034 uri: String,
1035 ) -> Self {
1036 let instruction = Box::new(CreateTokenCpiBuilderInstruction {
1037 __program,
1038 user,
1039 payer,
1040 coin_creator,
1041 global_config,
1042 base_mint,
1043 quote_mint,
1044 bonding_curve,
1045 base_vault,
1046 quote_vault,
1047 creator_fee_config,
1048 nexus_program,
1049 nexus_global_config,
1050 partner,
1051 partner_config,
1052 nexus_staking_config,
1053 staking_reward_state,
1054 reward_accrual,
1055 staking_vault,
1056 staking_wsol_vault,
1057 wsol_reward_accrual,
1058 pyth_price_feed,
1059 base_token_program,
1060 quote_token_program,
1061 wsol_token_program,
1062 associated_token_program,
1063 system_program,
1064 event_authority,
1065 program,
1066 platform_config,
1067 creator_platform,
1068 creator_id,
1069 creator_hash,
1070 name,
1071 symbol,
1072 uri,
1073 __remaining_accounts: Vec::new(),
1074 });
1075 Self { instruction }
1076 }
1077 #[inline(always)]
1079 pub fn add_remaining_account(
1080 &mut self,
1081 account: &'b solana_program::account_info::AccountInfo<'a>,
1082 is_writable: bool,
1083 is_signer: bool,
1084 ) -> &mut Self {
1085 self.instruction.__remaining_accounts.push((
1086 account,
1087 is_writable,
1088 is_signer,
1089 ));
1090 self
1091 }
1092 #[inline(always)]
1097 pub fn add_remaining_accounts(
1098 &mut self,
1099 accounts: &[(
1100 &'b solana_program::account_info::AccountInfo<'a>,
1101 bool,
1102 bool,
1103 )],
1104 ) -> &mut Self {
1105 self.instruction
1106 .__remaining_accounts
1107 .extend_from_slice(accounts);
1108 self
1109 }
1110 #[inline(always)]
1111 pub fn invoke(&self) -> solana_program::entrypoint::ProgramResult {
1112 self.invoke_signed(&[])
1113 }
1114 #[allow(clippy::clone_on_copy)]
1115 #[allow(clippy::vec_init_then_push)]
1116 pub fn invoke_signed(
1117 &self,
1118 signers_seeds: &[&[&[u8]]],
1119 ) -> solana_program::entrypoint::ProgramResult {
1120 let args = CreateTokenInstructionArgs {
1121 platform_config: self.instruction.platform_config.clone(),
1122 creator_platform: self.instruction.creator_platform.clone(),
1123 creator_id: self.instruction.creator_id.clone(),
1124 creator_hash: self.instruction.creator_hash.clone(),
1125 name: self.instruction.name.clone(),
1126 symbol: self.instruction.symbol.clone(),
1127 uri: self.instruction.uri.clone(),
1128 };
1129 let instruction = CreateTokenCpi {
1130 __program: self.instruction.__program,
1131 user: self.instruction.user,
1132 payer: self.instruction.payer,
1133 coin_creator: self.instruction.coin_creator,
1134 global_config: self.instruction.global_config,
1135 base_mint: self.instruction.base_mint,
1136 quote_mint: self.instruction.quote_mint,
1137 bonding_curve: self.instruction.bonding_curve,
1138 base_vault: self.instruction.base_vault,
1139 quote_vault: self.instruction.quote_vault,
1140 creator_fee_config: self.instruction.creator_fee_config,
1141 nexus_program: self.instruction.nexus_program,
1142 nexus_global_config: self.instruction.nexus_global_config,
1143 partner: self.instruction.partner,
1144 partner_config: self.instruction.partner_config,
1145 nexus_staking_config: self.instruction.nexus_staking_config,
1146 staking_reward_state: self.instruction.staking_reward_state,
1147 reward_accrual: self.instruction.reward_accrual,
1148 staking_vault: self.instruction.staking_vault,
1149 staking_wsol_vault: self.instruction.staking_wsol_vault,
1150 wsol_reward_accrual: self.instruction.wsol_reward_accrual,
1151 pyth_price_feed: self.instruction.pyth_price_feed,
1152 base_token_program: self.instruction.base_token_program,
1153 quote_token_program: self.instruction.quote_token_program,
1154 wsol_token_program: self.instruction.wsol_token_program,
1155 associated_token_program: self.instruction.associated_token_program,
1156 system_program: self.instruction.system_program,
1157 event_authority: self.instruction.event_authority,
1158 program: self.instruction.program,
1159 __args: args,
1160 };
1161 instruction.invoke_signed_with_remaining_accounts(
1162 signers_seeds,
1163 &self.instruction.__remaining_accounts,
1164 )
1165 }
1166}
1167
1168#[derive(Clone, Debug)]
1169struct CreateTokenCpiBuilderInstruction<'a, 'b> {
1170 __program: &'b solana_program::account_info::AccountInfo<'a>,
1171 user: &'b solana_program::account_info::AccountInfo<'a>,
1172 payer: &'b solana_program::account_info::AccountInfo<'a>,
1173 coin_creator: &'b solana_program::account_info::AccountInfo<'a>,
1174 global_config: &'b solana_program::account_info::AccountInfo<'a>,
1175 base_mint: &'b solana_program::account_info::AccountInfo<'a>,
1176 quote_mint: &'b solana_program::account_info::AccountInfo<'a>,
1177 bonding_curve: &'b solana_program::account_info::AccountInfo<'a>,
1178 base_vault: &'b solana_program::account_info::AccountInfo<'a>,
1179 quote_vault: &'b solana_program::account_info::AccountInfo<'a>,
1180 creator_fee_config: &'b solana_program::account_info::AccountInfo<'a>,
1181 nexus_program: &'b solana_program::account_info::AccountInfo<'a>,
1182 nexus_global_config: &'b solana_program::account_info::AccountInfo<'a>,
1183 partner: (&'b solana_program::account_info::AccountInfo<'a>, bool),
1184 partner_config: &'b solana_program::account_info::AccountInfo<'a>,
1185 nexus_staking_config: &'b solana_program::account_info::AccountInfo<'a>,
1186 staking_reward_state: &'b solana_program::account_info::AccountInfo<'a>,
1187 reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
1188 staking_vault: &'b solana_program::account_info::AccountInfo<'a>,
1189 staking_wsol_vault: &'b solana_program::account_info::AccountInfo<'a>,
1190 wsol_reward_accrual: &'b solana_program::account_info::AccountInfo<'a>,
1191 pyth_price_feed: &'b solana_program::account_info::AccountInfo<'a>,
1192 base_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1193 quote_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1194 wsol_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1195 associated_token_program: &'b solana_program::account_info::AccountInfo<'a>,
1196 system_program: &'b solana_program::account_info::AccountInfo<'a>,
1197 event_authority: &'b solana_program::account_info::AccountInfo<'a>,
1198 program: &'b solana_program::account_info::AccountInfo<'a>,
1199 platform_config: Address,
1200 creator_platform: String,
1201 creator_id: String,
1202 creator_hash: Address,
1203 name: String,
1204 symbol: String,
1205 uri: String,
1206 __remaining_accounts: Vec<(
1208 &'b solana_program::account_info::AccountInfo<'a>,
1209 bool,
1210 bool,
1211 )>,
1212}