trident-template 0.10.0-rc.2

Trident is Rust based fuzzing framework for Solana programs written in Anchor.
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

use quote::ToTokens;
use syn::parse_quote;

use crate::Template;

impl Template {
    pub fn get_instructions(&self) -> Vec<(String, String)> {
        self.instructions
            .iter()
            .map(|(name, file)| (name.clone(), file.into_token_stream().to_string()))
            .collect()
    }
    pub fn get_transactions(&self) -> Vec<(String, String)> {
        self.transactions
            .iter()
            .map(|(name, file)| (name.clone(), file.into_token_stream().to_string()))
            .collect()
    }
    pub fn get_instructions_mod(&self) -> String {
        let (modules, uses): (Vec<syn::ItemMod>, Vec<syn::ItemUse>) = self
            .instructions_mod
            .iter()
            .map(|mod_definition| {
                (
                    mod_definition.module.clone(),
                    mod_definition.use_statement.clone(),
                )
            })
            .unzip();

        let mod_file: syn::File = parse_quote! {
            #(#modules)*
            #(#uses)*
        };

        mod_file.into_token_stream().to_string()
    }
    pub fn get_transactions_mod(&self) -> String {
        let (modules, uses): (Vec<syn::ItemMod>, Vec<syn::ItemUse>) = self
            .transactions_mod
            .iter()
            .map(|mod_definition| {
                (
                    mod_definition.module.clone(),
                    mod_definition.use_statement.clone(),
                )
            })
            .unzip();

        let mod_file: syn::File = parse_quote! {
            #(#modules)*
            #(#uses)*
        };

        mod_file.into_token_stream().to_string()
    }
    pub fn get_fuzz_transactions(&self) -> String {
        let transaction_variants = self.fuzz_transactions.clone();
        let account_storages: Vec<syn::Field> = self
            .account_storages
            .iter()
            .map(|account_storage| account_storage.1.clone())
            .collect();

        let module_definition: syn::File = parse_quote! {
            use trident_fuzz::fuzzing::*;
            use crate::transactions::*;

            /// FuzzTransactions contains all available transactions
            ///
            /// You can create your own transactions by adding new variants to the enum.
            ///
            /// Docs: https://ackee.xyz/trident/docs/latest/trident-api-macro/trident-types/fuzz-transactions/
            #[derive(Arbitrary, TransactionSelector)]
            pub enum FuzzTransactions {
                #(#transaction_variants),*
            }

            /// FuzzAccounts contains all available accounts
            ///
            /// You can create your own accounts by adding new fields to the struct.
            ///
            /// Docs: https://ackee.xyz/trident/docs/latest/trident-api-macro/trident-types/fuzz-accounts/
            #[derive(Default)]
            pub struct FuzzAccounts {
                #(#account_storages),*
            }

        };
        module_definition.into_token_stream().to_string()
    }
    pub fn get_custom_types(&self) -> String {
        let custom_types = self.custom_types.clone();
        let common_header = quote::quote! {
            use borsh::{BorshDeserialize, BorshSerialize};
            use trident_fuzz::fuzzing::*;

            /// File containing all custom types which can be used
            /// in transactions and instructions or invariant checks.
            ///
            /// You can define your own custom types here.
        };

        let module_definition: syn::File = match custom_types.len() {
            0 => parse_quote! {
                #common_header

                #[derive(Arbitrary, Debug, BorshDeserialize, BorshSerialize, Clone)]
                pub struct ExampleType {
                    example_data: u8,
                }
            },
            _ => parse_quote! {
                #common_header

                #(#custom_types)*
            },
        };
        module_definition.into_token_stream().to_string()
    }

    pub fn get_test_fuzz(&self) -> String {
        match &self.test_fuzz {
            Some(file) => file.into_token_stream().to_string(),
            None => panic!("test_fuzz.rs not prepared, aborting"),
        }
    }
}