solores 0.7.0

Solana IDL to Rust client / CPI interface generator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

use heck::ToPascalCase;
use proc_macro2::{Ident, TokenStream};
use quote::{format_ident, quote, ToTokens};

use crate::idl_format::IdlCodegenModule;

mod instruction;
pub use instruction::*;

pub struct IxCodegenModule<'a> {
    pub program_name: &'a str,
    pub instructions: &'a [NamedInstruction],
}

impl<'a> IxCodegenModule<'a> {
    pub fn program_ix_enum_ident(&self) -> Ident {
        format_ident!("{}ProgramIx", self.program_name.to_pascal_case())
    }
}

impl IdlCodegenModule for IxCodegenModule<'_> {
    fn name(&self) -> &str {
        "instructions"
    }

    fn gen_head(&self) -> TokenStream {
        let mut res = quote! {};
        let has_accounts = self
            .instructions
            .iter()
            .map(|ix| ix.has_accounts())
            .any(|b| b);
        let mut solana_program_imports = if has_accounts {
            quote! {
                account_info::AccountInfo,
                entrypoint::ProgramResult,
                instruction::{AccountMeta, Instruction},
                program::{invoke, invoke_signed},
                pubkey::Pubkey,
            }
        } else {
            quote! {
                entrypoint::ProgramResult,
                instruction::Instruction,
                program::{invoke, invoke_signed},
                pubkey::Pubkey,
            }
        };
        let has_privileged_accounts = self
            .instructions
            .iter()
            .map(|ix| ix.has_privileged_accounts())
            .any(|b| b);
        if has_privileged_accounts {
            solana_program_imports.extend(quote! {
                program_error::ProgramError,
            });
        }
        res.extend(quote! {
            use serde::{Serialize, Deserialize};
            use solana_program::{#solana_program_imports};
        });

        let has_defined_type = self
            .instructions
            .iter()
            .map(|ix| ix.args_has_defined_type())
            .any(|b| b);
        if has_defined_type {
            res.extend(quote! {
                use crate::*;
            });
        }

        // program ix enum
        let program_ix_enum_ident = self.program_ix_enum_ident();
        let program_ix_enum_variants = self.instructions.iter().map(enum_variant);

        res.extend(quote! {
            #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
            pub enum #program_ix_enum_ident {
                #(#program_ix_enum_variants),*
            }
        });

        if has_accounts {
            res.extend(quote! {
                fn invoke_instruction<'info, A: Into<[AccountInfo<'info>; N]>, const N: usize>(
                    ix: &Instruction,
                    accounts: A,
                ) -> ProgramResult {
                    let account_info: [AccountInfo<'info>; N] = accounts.into();
                    invoke(ix, &account_info)
                }
                fn invoke_instruction_signed<'info, A: Into<[AccountInfo<'info>; N]>, const N: usize>(
                    ix: &Instruction,
                    accounts: A,
                    seeds: &[&[&[u8]]],
                ) -> ProgramResult {
                    let account_info: [AccountInfo<'info>; N] = accounts.into();
                    invoke_signed(ix, &account_info, seeds)
                }
            });
        }

        res
    }

    fn gen_body(&self) -> TokenStream {
        let program_ix_enum_ident = self.program_ix_enum_ident();
        self.instructions
            .iter()
            .enumerate()
            .map(|(i, ix)| {
                NamedInstructionFull {
                    ix,
                    index: i,
                    program_ix_enum_ident: &program_ix_enum_ident,
                }
                .into_token_stream()
            })
            .collect()
    }
}

pub fn enum_variant(ix: &NamedInstruction) -> TokenStream {
    let variant_ident = ix.enum_variant_ident();
    let mut res = quote!(
        #variant_ident
    );
    if ix.has_ix_args() {
        let ix_args_ident = ix.ix_args_ident();
        res.extend(quote! {
            (#ix_args_ident)
        })
    }
    res
}