mpl_token_metadata/generated/instructions/
use.rs

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

mpl_token_metadata/generated/instructions/
use.rs
