trident-template 0.0.1

The trident template crate is dedicated to generated Trident fuzz test templates.
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

use convert_case::{Case, Casing};
use quote::format_ident;
use syn::{parse_quote, FnArg};

use trident_idl_spec::IdlInstructionAccounts;
use trident_idl_spec::{
    idl_type_to_syn_type, Idl, IdlField, IdlInstruction, IdlInstructionAccount,
    IdlInstructionAccountItem,
};

// Generate input structures for each instruction
pub(crate) fn get_instruction_inputs(idl: &Idl) -> Vec<syn::ItemStruct> {
    let _program_name = idl.metadata.name.to_case(Case::UpperCamel);

    idl.instructions
        .iter()
        .fold(Vec::new(), |mut instructions_data, instruction| {
            let instruction_name = instruction.name.to_case(Case::UpperCamel);

            // get instruction name
            let instruction_name_ident: syn::Ident = format_ident!("{}", &instruction_name);
            // get instruction data name
            let instruction_data_name: syn::Ident = format_ident!("{}Data", &instruction_name);
            // get instruction accounts name
            let instruction_accounts_name: syn::Ident =
                format_ident!("{}Accounts", &instruction_name);

            // Generate accounts and parameters
            let accounts = get_instruction_accounts(instruction);

            let data = get_instruction_data(instruction);

            // Define the input structures
            let instructions_inputs: syn::ItemStruct = parse_quote! {
                #[derive(Arbitrary, Debug)]
                pub struct #instruction_name_ident {
                     pub accounts: #instruction_accounts_name,
                     pub data: #instruction_data_name
                }
            };

            let instructions_input_accounts: syn::ItemStruct = parse_quote! {
                #[derive(Arbitrary, Debug)]
                pub struct #instruction_accounts_name {
                     #(pub #accounts),*
                }
            };

            let instructions_input_data: syn::ItemStruct = parse_quote! {
                /// Custom data types must derive `Debug` and `Arbitrary`.
                /// To do this, redefine the type in the fuzz test and implement the `From` trait
                /// to convert it into the type defined in the program.
                /// For more details, see: https://ackee.xyz/trident/docs/latest/features/fuzz-instructions/#custom-data-types
                #[derive(Arbitrary, Debug, BorshDeserialize, BorshSerialize)]
                pub struct #instruction_data_name {
                     #(pub #data),*
                }
            };

            instructions_data.push(instructions_inputs);
            instructions_data.push(instructions_input_accounts);
            instructions_data.push(instructions_input_data);
            instructions_data
        })
}

fn get_instruction_accounts(instruction: &IdlInstruction) -> Vec<syn::FnArg> {
    instruction
        .accounts
        .iter()
        .fold(Vec::new(), |mut account_parameters, account| {
            match account {
                IdlInstructionAccountItem::Composite(idl_instruction_accounts) => {
                    process_composite_account(idl_instruction_accounts, &mut account_parameters);
                }
                IdlInstructionAccountItem::Single(idl_instruction_account) => {
                    process_single_account(idl_instruction_account, &mut account_parameters);
                }
            };
            account_parameters
        })
}

fn process_composite_account(
    idl_instruction_accounts: &IdlInstructionAccounts,
    account_parameters: &mut Vec<syn::FnArg>,
) {
    for account in &idl_instruction_accounts.accounts {
        match account {
            IdlInstructionAccountItem::Single(idl_instruction_account) => {
                process_single_account(idl_instruction_account, account_parameters);
            }
            IdlInstructionAccountItem::Composite(idl_instruction_accounts) => {
                process_composite_account(idl_instruction_accounts, account_parameters);
            }
        }
    }
}

fn process_single_account(
    idl_instruction_account: &IdlInstructionAccount,
    account_parameters: &mut Vec<syn::FnArg>,
) {
    // If the account has constant address it is not needed to fuzz it
    // So it will not be generated as a parameter.
    if idl_instruction_account.address.is_none() {
        let name = format_ident!("{}", idl_instruction_account.name);
        let account: syn::FnArg = parse_quote!(#name: AccountId);
        account_parameters.push(account);
    }
}

fn get_instruction_data(instruction: &IdlInstruction) -> Vec<syn::FnArg> {
    instruction
        .args
        .iter()
        .fold(Vec::new(), |mut arguments, argument| {
            process_instruction_argument(argument, &mut arguments);
            arguments
        })
}

fn process_instruction_argument(argument: &IdlField, arguments: &mut Vec<FnArg>) {
    let arg_name = format_ident!("{}", argument.name);

    // convert type to syn type
    let (arg_type, _is_custom) = idl_type_to_syn_type(&argument.ty, 0, true);

    let parameter: syn::FnArg = parse_quote!(#arg_name: #arg_type);

    arguments.push(parameter);
}