Line data Source code
1 : // This is an auto-generated file. To add entries, edit fd_types.json
2 : #ifndef HEADER_FUZZ_FD_RUNTIME_TYPES
3 : #define HEADER_FUZZ_FD_RUNTIME_TYPES
4 :
5 : #pragma GCC diagnostic ignored "-Wunused-parameter"
6 : #pragma GCC diagnostic ignored "-Wunused-variable"
7 : #define SOURCE_fd_src_flamenco_types_fd_types_c
8 : #include "fd_types.h"
9 : #include "fd_types_custom.h"
10 :
11 : size_t LLVMFuzzerMutate(uchar *data, size_t size, size_t max_size);
12 :
13 0 : void *fd_flamenco_txn_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
14 0 : fd_flamenco_txn_t *self = (fd_flamenco_txn_t *) mem;
15 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_flamenco_txn_t);
16 0 : fd_flamenco_txn_new(mem);
17 0 : LLVMFuzzerMutate( &self->txn_buf[0], FD_TXN_MAX_SZ, FD_TXN_MAX_SZ );
18 0 : self->raw_sz = fd_rng_ulong( rng ) % FD_TXN_MTU;
19 0 : LLVMFuzzerMutate( &self->raw[0], self->raw_sz, self->raw_sz );
20 0 : return mem;
21 0 : }
22 :
23 0 : void *fd_hash_generate(void *mem, void **alloc_mem, fd_rng_t * rng) {
24 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_hash_t);
25 0 : fd_hash_new(mem);
26 0 : LLVMFuzzerMutate( (uchar *) mem, sizeof(fd_hash_t), sizeof(fd_hash_t));
27 0 : return mem;
28 0 : }
29 :
30 0 : void *fd_pubkey_generate(void *mem, void **alloc_mem, fd_rng_t * rng) {
31 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t);
32 0 : fd_pubkey_new(mem);
33 0 : LLVMFuzzerMutate( (uchar *) mem, sizeof(fd_pubkey_t), sizeof(fd_pubkey_t));
34 0 : return mem;
35 0 : }
36 :
37 0 : void *fd_signature_generate(void *mem, void **alloc_mem, fd_rng_t * rng) {
38 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_signature_t);
39 0 : fd_signature_new(mem);
40 0 : LLVMFuzzerMutate( (uchar *) mem, sizeof(fd_signature_t), sizeof(fd_signature_t));
41 0 : return mem;
42 0 : }
43 :
44 0 : void *fd_gossip_ip4_addr_generate(void *mem, void **alloc_mem, fd_rng_t * rng) {
45 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_ip4_addr_t);
46 0 : fd_gossip_ip4_addr_new(mem);
47 0 : LLVMFuzzerMutate( (uchar *) mem, sizeof(fd_gossip_ip4_addr_t), sizeof(fd_gossip_ip4_addr_t));
48 0 : return mem;
49 0 : }
50 :
51 0 : void *fd_gossip_ip6_addr_generate(void *mem, void **alloc_mem, fd_rng_t * rng) {
52 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_ip6_addr_t);
53 0 : fd_gossip_ip6_addr_new(mem);
54 0 : LLVMFuzzerMutate( (uchar *) mem, sizeof(fd_gossip_ip6_addr_t), sizeof(fd_gossip_ip6_addr_t));
55 0 : return mem;
56 0 : }
57 :
58 0 : void *fd_feature_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
59 0 : fd_feature_t *self = (fd_feature_t *) mem;
60 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_feature_t);
61 0 : fd_feature_new(mem);
62 0 : {
63 0 : self->has_activated_at = fd_rng_uchar( rng ) % 2;
64 0 : if( self->has_activated_at ) {
65 0 : LLVMFuzzerMutate( (uchar *)&(self->activated_at), sizeof(ulong), sizeof(ulong) );
66 0 : }
67 0 : }
68 0 : return mem;
69 0 : }
70 :
71 0 : void *fd_fee_calculator_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
72 0 : fd_fee_calculator_t *self = (fd_fee_calculator_t *) mem;
73 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_fee_calculator_t);
74 0 : fd_fee_calculator_new(mem);
75 0 : self->lamports_per_signature = fd_rng_ulong( rng );
76 0 : return mem;
77 0 : }
78 :
79 0 : void *fd_hash_age_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
80 0 : fd_hash_age_t *self = (fd_hash_age_t *) mem;
81 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_hash_age_t);
82 0 : fd_hash_age_new(mem);
83 0 : fd_fee_calculator_generate( &self->fee_calculator, alloc_mem, rng );
84 0 : self->hash_index = fd_rng_ulong( rng );
85 0 : self->timestamp = fd_rng_ulong( rng );
86 0 : return mem;
87 0 : }
88 :
89 0 : void *fd_hash_hash_age_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
90 0 : fd_hash_hash_age_pair_t *self = (fd_hash_hash_age_pair_t *) mem;
91 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_hash_hash_age_pair_t);
92 0 : fd_hash_hash_age_pair_new(mem);
93 0 : fd_hash_generate( &self->key, alloc_mem, rng );
94 0 : fd_hash_age_generate( &self->val, alloc_mem, rng );
95 0 : return mem;
96 0 : }
97 :
98 0 : void *fd_block_hash_vec_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
99 0 : fd_block_hash_vec_t *self = (fd_block_hash_vec_t *) mem;
100 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_block_hash_vec_t);
101 0 : fd_block_hash_vec_new(mem);
102 0 : self->last_hash_index = fd_rng_ulong( rng );
103 0 : {
104 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
105 0 : if( !is_null ) {
106 0 : self->last_hash = (fd_hash_t *) *alloc_mem;
107 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_hash_t);
108 0 : fd_hash_new( self->last_hash );
109 0 : fd_hash_generate( self->last_hash, alloc_mem, rng );
110 0 : }
111 0 : else {
112 0 : self->last_hash = NULL;
113 0 : }
114 0 : }
115 0 : self->ages_len = fd_rng_ulong( rng ) % 8;
116 0 : if( self->ages_len ) {
117 0 : self->ages = (fd_hash_hash_age_pair_t *) *alloc_mem;
118 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_hash_hash_age_pair_t)*self->ages_len;
119 0 : for( ulong i=0; i < self->ages_len; i++ ) {
120 0 : fd_hash_hash_age_pair_new( self->ages + i );
121 0 : fd_hash_hash_age_pair_generate( self->ages + i, alloc_mem, rng );
122 0 : }
123 0 : } else {
124 0 : self->ages = NULL;
125 0 : }
126 0 : self->max_age = fd_rng_ulong( rng );
127 0 : return mem;
128 0 : }
129 :
130 0 : void *fd_fee_rate_governor_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
131 0 : fd_fee_rate_governor_t *self = (fd_fee_rate_governor_t *) mem;
132 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_fee_rate_governor_t);
133 0 : fd_fee_rate_governor_new(mem);
134 0 : self->target_lamports_per_signature = fd_rng_ulong( rng );
135 0 : self->target_signatures_per_slot = fd_rng_ulong( rng );
136 0 : self->min_lamports_per_signature = fd_rng_ulong( rng );
137 0 : self->max_lamports_per_signature = fd_rng_ulong( rng );
138 0 : self->burn_percent = fd_rng_uchar( rng );
139 0 : return mem;
140 0 : }
141 :
142 0 : void *fd_slot_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
143 0 : fd_slot_pair_t *self = (fd_slot_pair_t *) mem;
144 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_pair_t);
145 0 : fd_slot_pair_new(mem);
146 0 : self->slot = fd_rng_ulong( rng );
147 0 : self->val = fd_rng_ulong( rng );
148 0 : return mem;
149 0 : }
150 :
151 0 : void *fd_hard_forks_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
152 0 : fd_hard_forks_t *self = (fd_hard_forks_t *) mem;
153 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_hard_forks_t);
154 0 : fd_hard_forks_new(mem);
155 0 : self->hard_forks_len = fd_rng_ulong( rng ) % 8;
156 0 : if( self->hard_forks_len ) {
157 0 : self->hard_forks = (fd_slot_pair_t *) *alloc_mem;
158 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_pair_t)*self->hard_forks_len;
159 0 : for( ulong i=0; i < self->hard_forks_len; i++ ) {
160 0 : fd_slot_pair_new( self->hard_forks + i );
161 0 : fd_slot_pair_generate( self->hard_forks + i, alloc_mem, rng );
162 0 : }
163 0 : } else {
164 0 : self->hard_forks = NULL;
165 0 : }
166 0 : return mem;
167 0 : }
168 :
169 0 : void *fd_inflation_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
170 0 : fd_inflation_t *self = (fd_inflation_t *) mem;
171 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_inflation_t);
172 0 : fd_inflation_new(mem);
173 0 : self->initial = fd_rng_double_o( rng );
174 0 : self->terminal = fd_rng_double_o( rng );
175 0 : self->taper = fd_rng_double_o( rng );
176 0 : self->foundation = fd_rng_double_o( rng );
177 0 : self->foundation_term = fd_rng_double_o( rng );
178 0 : self->unused = fd_rng_double_o( rng );
179 0 : return mem;
180 0 : }
181 :
182 0 : void *fd_rent_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
183 0 : fd_rent_t *self = (fd_rent_t *) mem;
184 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_rent_t);
185 0 : fd_rent_new(mem);
186 0 : self->lamports_per_uint8_year = fd_rng_ulong( rng );
187 0 : self->exemption_threshold = fd_rng_double_o( rng );
188 0 : self->burn_percent = fd_rng_uchar( rng );
189 0 : return mem;
190 0 : }
191 :
192 0 : void *fd_epoch_schedule_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
193 0 : fd_epoch_schedule_t *self = (fd_epoch_schedule_t *) mem;
194 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_epoch_schedule_t);
195 0 : fd_epoch_schedule_new(mem);
196 0 : self->slots_per_epoch = fd_rng_ulong( rng );
197 0 : self->leader_schedule_slot_offset = fd_rng_ulong( rng );
198 0 : self->warmup = fd_rng_uchar( rng );
199 0 : self->first_normal_epoch = fd_rng_ulong( rng );
200 0 : self->first_normal_slot = fd_rng_ulong( rng );
201 0 : return mem;
202 0 : }
203 :
204 0 : void *fd_rent_collector_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
205 0 : fd_rent_collector_t *self = (fd_rent_collector_t *) mem;
206 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_rent_collector_t);
207 0 : fd_rent_collector_new(mem);
208 0 : self->epoch = fd_rng_ulong( rng );
209 0 : fd_epoch_schedule_generate( &self->epoch_schedule, alloc_mem, rng );
210 0 : self->slots_per_year = fd_rng_double_o( rng );
211 0 : fd_rent_generate( &self->rent, alloc_mem, rng );
212 0 : return mem;
213 0 : }
214 :
215 0 : void *fd_stake_history_entry_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
216 0 : fd_stake_history_entry_t *self = (fd_stake_history_entry_t *) mem;
217 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_history_entry_t);
218 0 : fd_stake_history_entry_new(mem);
219 0 : self->effective = fd_rng_ulong( rng );
220 0 : self->activating = fd_rng_ulong( rng );
221 0 : self->deactivating = fd_rng_ulong( rng );
222 0 : return mem;
223 0 : }
224 :
225 0 : void *fd_epoch_stake_history_entry_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
226 0 : fd_epoch_stake_history_entry_pair_t *self = (fd_epoch_stake_history_entry_pair_t *) mem;
227 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_epoch_stake_history_entry_pair_t);
228 0 : fd_epoch_stake_history_entry_pair_new(mem);
229 0 : self->epoch = fd_rng_ulong( rng );
230 0 : fd_stake_history_entry_generate( &self->entry, alloc_mem, rng );
231 0 : return mem;
232 0 : }
233 :
234 0 : void *fd_stake_history_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
235 0 : fd_stake_history_t *self = (fd_stake_history_t *) mem;
236 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_history_t);
237 0 : fd_stake_history_new(mem);
238 0 : self->fd_stake_history_len = fd_rng_ulong( rng ) % 8;
239 0 : self->fd_stake_history_size = 512;
240 0 : self->fd_stake_history_offset = 0;
241 0 : for( ulong i=0; i<self->fd_stake_history_len; i++ ) {
242 0 : fd_epoch_stake_history_entry_pair_generate( self->fd_stake_history + i, alloc_mem, rng );
243 0 : }
244 0 : return mem;
245 0 : }
246 :
247 0 : void *fd_solana_account_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
248 0 : fd_solana_account_t *self = (fd_solana_account_t *) mem;
249 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_solana_account_t);
250 0 : fd_solana_account_new(mem);
251 0 : self->lamports = fd_rng_ulong( rng );
252 0 : self->data_len = fd_rng_ulong( rng ) % 8;
253 0 : if( self->data_len ) {
254 0 : self->data = (uchar *) *alloc_mem;
255 0 : *alloc_mem = (uchar *) *alloc_mem + self->data_len;
256 0 : for( ulong i=0; i < self->data_len; ++i) { self->data[i] = fd_rng_uchar( rng ) % 0x80; }
257 0 : } else {
258 0 : self->data = NULL;
259 0 : }
260 0 : fd_pubkey_generate( &self->owner, alloc_mem, rng );
261 0 : self->executable = fd_rng_uchar( rng );
262 0 : self->rent_epoch = fd_rng_ulong( rng );
263 0 : return mem;
264 0 : }
265 :
266 0 : void *fd_solana_account_stored_meta_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
267 0 : fd_solana_account_stored_meta_t *self = (fd_solana_account_stored_meta_t *) mem;
268 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_solana_account_stored_meta_t);
269 0 : fd_solana_account_stored_meta_new(mem);
270 0 : self->write_version_obsolete = fd_rng_ulong( rng );
271 0 : self->data_len = fd_rng_ulong( rng );
272 0 : LLVMFuzzerMutate( &self->pubkey[0], sizeof(self->pubkey), sizeof(self->pubkey) );
273 0 : return mem;
274 0 : }
275 :
276 0 : void *fd_solana_account_meta_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
277 0 : fd_solana_account_meta_t *self = (fd_solana_account_meta_t *) mem;
278 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_solana_account_meta_t);
279 0 : fd_solana_account_meta_new(mem);
280 0 : self->lamports = fd_rng_ulong( rng );
281 0 : self->rent_epoch = fd_rng_ulong( rng );
282 0 : LLVMFuzzerMutate( &self->owner[0], sizeof(self->owner), sizeof(self->owner) );
283 0 : self->executable = fd_rng_uchar( rng );
284 0 : LLVMFuzzerMutate( self->padding, 3, 3 );
285 0 : return mem;
286 0 : }
287 :
288 0 : void *fd_solana_account_hdr_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
289 0 : fd_solana_account_hdr_t *self = (fd_solana_account_hdr_t *) mem;
290 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_solana_account_hdr_t);
291 0 : fd_solana_account_hdr_new(mem);
292 0 : fd_solana_account_stored_meta_generate( &self->meta, alloc_mem, rng );
293 0 : fd_solana_account_meta_generate( &self->info, alloc_mem, rng );
294 0 : LLVMFuzzerMutate( self->padding, 4, 4 );
295 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
296 0 : return mem;
297 0 : }
298 :
299 0 : void *fd_account_meta_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
300 0 : fd_account_meta_t *self = (fd_account_meta_t *) mem;
301 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_account_meta_t);
302 0 : fd_account_meta_new(mem);
303 0 : self->magic = fd_rng_ushort( rng );
304 0 : self->hlen = fd_rng_ushort( rng );
305 0 : self->dlen = fd_rng_ulong( rng );
306 0 : LLVMFuzzerMutate( &self->hash[0], sizeof(self->hash), sizeof(self->hash) );
307 0 : self->slot = fd_rng_ulong( rng );
308 0 : fd_solana_account_meta_generate( &self->info, alloc_mem, rng );
309 0 : return mem;
310 0 : }
311 :
312 0 : void *fd_vote_accounts_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
313 0 : fd_vote_accounts_pair_t *self = (fd_vote_accounts_pair_t *) mem;
314 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_accounts_pair_t);
315 0 : fd_vote_accounts_pair_new(mem);
316 0 : fd_pubkey_generate( &self->key, alloc_mem, rng );
317 0 : self->stake = fd_rng_ulong( rng );
318 0 : fd_solana_account_generate( &self->value, alloc_mem, rng );
319 0 : return mem;
320 0 : }
321 :
322 0 : void *fd_vote_accounts_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
323 0 : fd_vote_accounts_t *self = (fd_vote_accounts_t *) mem;
324 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_accounts_t);
325 0 : fd_vote_accounts_new(mem);
326 0 : ulong vote_accounts_len = fd_rng_ulong( rng ) % 8;
327 0 : self->vote_accounts_pool = fd_vote_accounts_pair_t_map_join_new( alloc_mem, fd_ulong_max( vote_accounts_len, 50000 ) );
328 0 : self->vote_accounts_root = NULL;
329 0 : for( ulong i=0; i < vote_accounts_len; i++ ) {
330 0 : fd_vote_accounts_pair_t_mapnode_t * node = fd_vote_accounts_pair_t_map_acquire( self->vote_accounts_pool );
331 0 : fd_vote_accounts_pair_generate( &node->elem, alloc_mem, rng );
332 0 : fd_vote_accounts_pair_t_map_insert( self->vote_accounts_pool, &self->vote_accounts_root, node );
333 0 : }
334 0 : return mem;
335 0 : }
336 :
337 0 : void *fd_account_keys_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
338 0 : fd_account_keys_pair_t *self = (fd_account_keys_pair_t *) mem;
339 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_account_keys_pair_t);
340 0 : fd_account_keys_pair_new(mem);
341 0 : fd_pubkey_generate( &self->key, alloc_mem, rng );
342 0 : self->exists = fd_rng_uchar( rng );
343 0 : return mem;
344 0 : }
345 :
346 0 : void *fd_account_keys_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
347 0 : fd_account_keys_t *self = (fd_account_keys_t *) mem;
348 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_account_keys_t);
349 0 : fd_account_keys_new(mem);
350 0 : ulong account_keys_len = fd_rng_ulong( rng ) % 8;
351 0 : self->account_keys_pool = fd_account_keys_pair_t_map_join_new( alloc_mem, fd_ulong_max( account_keys_len, 100000 ) );
352 0 : self->account_keys_root = NULL;
353 0 : for( ulong i=0; i < account_keys_len; i++ ) {
354 0 : fd_account_keys_pair_t_mapnode_t * node = fd_account_keys_pair_t_map_acquire( self->account_keys_pool );
355 0 : fd_account_keys_pair_generate( &node->elem, alloc_mem, rng );
356 0 : fd_account_keys_pair_t_map_insert( self->account_keys_pool, &self->account_keys_root, node );
357 0 : }
358 0 : return mem;
359 0 : }
360 :
361 0 : void *fd_delegation_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
362 0 : fd_delegation_t *self = (fd_delegation_t *) mem;
363 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_delegation_t);
364 0 : fd_delegation_new(mem);
365 0 : fd_pubkey_generate( &self->voter_pubkey, alloc_mem, rng );
366 0 : self->stake = fd_rng_ulong( rng );
367 0 : self->activation_epoch = fd_rng_ulong( rng );
368 0 : self->deactivation_epoch = fd_rng_ulong( rng );
369 0 : self->warmup_cooldown_rate = fd_rng_double_o( rng );
370 0 : return mem;
371 0 : }
372 :
373 0 : void *fd_delegation_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
374 0 : fd_delegation_pair_t *self = (fd_delegation_pair_t *) mem;
375 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_delegation_pair_t);
376 0 : fd_delegation_pair_new(mem);
377 0 : fd_pubkey_generate( &self->account, alloc_mem, rng );
378 0 : fd_delegation_generate( &self->delegation, alloc_mem, rng );
379 0 : return mem;
380 0 : }
381 :
382 0 : void *fd_stake_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
383 0 : fd_stake_t *self = (fd_stake_t *) mem;
384 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_t);
385 0 : fd_stake_new(mem);
386 0 : fd_delegation_generate( &self->delegation, alloc_mem, rng );
387 0 : self->credits_observed = fd_rng_ulong( rng );
388 0 : return mem;
389 0 : }
390 :
391 0 : void *fd_stake_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
392 0 : fd_stake_pair_t *self = (fd_stake_pair_t *) mem;
393 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_pair_t);
394 0 : fd_stake_pair_new(mem);
395 0 : fd_pubkey_generate( &self->account, alloc_mem, rng );
396 0 : fd_stake_generate( &self->stake, alloc_mem, rng );
397 0 : return mem;
398 0 : }
399 :
400 0 : void *fd_stakes_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
401 0 : fd_stakes_t *self = (fd_stakes_t *) mem;
402 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stakes_t);
403 0 : fd_stakes_new(mem);
404 0 : fd_vote_accounts_generate( &self->vote_accounts, alloc_mem, rng );
405 0 : ulong stake_delegations_len = fd_rng_ulong( rng ) % 8;
406 0 : self->stake_delegations_pool = fd_delegation_pair_t_map_join_new( alloc_mem, fd_ulong_max( stake_delegations_len, 2000000 ) );
407 0 : self->stake_delegations_root = NULL;
408 0 : for( ulong i=0; i < stake_delegations_len; i++ ) {
409 0 : fd_delegation_pair_t_mapnode_t * node = fd_delegation_pair_t_map_acquire( self->stake_delegations_pool );
410 0 : fd_delegation_pair_generate( &node->elem, alloc_mem, rng );
411 0 : fd_delegation_pair_t_map_insert( self->stake_delegations_pool, &self->stake_delegations_root, node );
412 0 : }
413 0 : self->unused = fd_rng_ulong( rng );
414 0 : self->epoch = fd_rng_ulong( rng );
415 0 : fd_stake_history_generate( &self->stake_history, alloc_mem, rng );
416 0 : return mem;
417 0 : }
418 :
419 0 : void *fd_stakes_stake_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
420 0 : fd_stakes_stake_t *self = (fd_stakes_stake_t *) mem;
421 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stakes_stake_t);
422 0 : fd_stakes_stake_new(mem);
423 0 : fd_vote_accounts_generate( &self->vote_accounts, alloc_mem, rng );
424 0 : ulong stake_delegations_len = fd_rng_ulong( rng ) % 8;
425 0 : self->stake_delegations_pool = fd_stake_pair_t_map_join_new( alloc_mem, stake_delegations_len );
426 0 : self->stake_delegations_root = NULL;
427 0 : for( ulong i=0; i < stake_delegations_len; i++ ) {
428 0 : fd_stake_pair_t_mapnode_t * node = fd_stake_pair_t_map_acquire( self->stake_delegations_pool );
429 0 : fd_stake_pair_generate( &node->elem, alloc_mem, rng );
430 0 : fd_stake_pair_t_map_insert( self->stake_delegations_pool, &self->stake_delegations_root, node );
431 0 : }
432 0 : self->unused = fd_rng_ulong( rng );
433 0 : self->epoch = fd_rng_ulong( rng );
434 0 : fd_stake_history_generate( &self->stake_history, alloc_mem, rng );
435 0 : return mem;
436 0 : }
437 :
438 0 : void *fd_bank_incremental_snapshot_persistence_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
439 0 : fd_bank_incremental_snapshot_persistence_t *self = (fd_bank_incremental_snapshot_persistence_t *) mem;
440 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bank_incremental_snapshot_persistence_t);
441 0 : fd_bank_incremental_snapshot_persistence_new(mem);
442 0 : self->full_slot = fd_rng_ulong( rng );
443 0 : fd_hash_generate( &self->full_hash, alloc_mem, rng );
444 0 : self->full_capitalization = fd_rng_ulong( rng );
445 0 : fd_hash_generate( &self->incremental_hash, alloc_mem, rng );
446 0 : self->incremental_capitalization = fd_rng_ulong( rng );
447 0 : return mem;
448 0 : }
449 :
450 0 : void *fd_node_vote_accounts_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
451 0 : fd_node_vote_accounts_t *self = (fd_node_vote_accounts_t *) mem;
452 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_node_vote_accounts_t);
453 0 : fd_node_vote_accounts_new(mem);
454 0 : self->vote_accounts_len = fd_rng_ulong( rng ) % 8;
455 0 : if( self->vote_accounts_len ) {
456 0 : self->vote_accounts = (fd_pubkey_t *) *alloc_mem;
457 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t)*self->vote_accounts_len;
458 0 : for( ulong i=0; i < self->vote_accounts_len; i++ ) {
459 0 : fd_pubkey_new( self->vote_accounts + i );
460 0 : fd_pubkey_generate( self->vote_accounts + i, alloc_mem, rng );
461 0 : }
462 0 : } else {
463 0 : self->vote_accounts = NULL;
464 0 : }
465 0 : self->total_stake = fd_rng_ulong( rng );
466 0 : return mem;
467 0 : }
468 :
469 0 : void *fd_pubkey_node_vote_accounts_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
470 0 : fd_pubkey_node_vote_accounts_pair_t *self = (fd_pubkey_node_vote_accounts_pair_t *) mem;
471 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_node_vote_accounts_pair_t);
472 0 : fd_pubkey_node_vote_accounts_pair_new(mem);
473 0 : fd_pubkey_generate( &self->key, alloc_mem, rng );
474 0 : fd_node_vote_accounts_generate( &self->value, alloc_mem, rng );
475 0 : return mem;
476 0 : }
477 :
478 0 : void *fd_pubkey_pubkey_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
479 0 : fd_pubkey_pubkey_pair_t *self = (fd_pubkey_pubkey_pair_t *) mem;
480 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_pubkey_pair_t);
481 0 : fd_pubkey_pubkey_pair_new(mem);
482 0 : fd_pubkey_generate( &self->key, alloc_mem, rng );
483 0 : fd_pubkey_generate( &self->value, alloc_mem, rng );
484 0 : return mem;
485 0 : }
486 :
487 0 : void *fd_epoch_stakes_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
488 0 : fd_epoch_stakes_t *self = (fd_epoch_stakes_t *) mem;
489 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_epoch_stakes_t);
490 0 : fd_epoch_stakes_new(mem);
491 0 : fd_stakes_generate( &self->stakes, alloc_mem, rng );
492 0 : self->total_stake = fd_rng_ulong( rng );
493 0 : ulong node_id_to_vote_accounts_len = fd_rng_ulong( rng ) % 8;
494 0 : self->node_id_to_vote_accounts_pool = fd_pubkey_node_vote_accounts_pair_t_map_join_new( alloc_mem, node_id_to_vote_accounts_len );
495 0 : self->node_id_to_vote_accounts_root = NULL;
496 0 : for( ulong i=0; i < node_id_to_vote_accounts_len; i++ ) {
497 0 : fd_pubkey_node_vote_accounts_pair_t_mapnode_t * node = fd_pubkey_node_vote_accounts_pair_t_map_acquire( self->node_id_to_vote_accounts_pool );
498 0 : fd_pubkey_node_vote_accounts_pair_generate( &node->elem, alloc_mem, rng );
499 0 : fd_pubkey_node_vote_accounts_pair_t_map_insert( self->node_id_to_vote_accounts_pool, &self->node_id_to_vote_accounts_root, node );
500 0 : }
501 0 : ulong epoch_authorized_voters_len = fd_rng_ulong( rng ) % 8;
502 0 : self->epoch_authorized_voters_pool = fd_pubkey_pubkey_pair_t_map_join_new( alloc_mem, epoch_authorized_voters_len );
503 0 : self->epoch_authorized_voters_root = NULL;
504 0 : for( ulong i=0; i < epoch_authorized_voters_len; i++ ) {
505 0 : fd_pubkey_pubkey_pair_t_mapnode_t * node = fd_pubkey_pubkey_pair_t_map_acquire( self->epoch_authorized_voters_pool );
506 0 : fd_pubkey_pubkey_pair_generate( &node->elem, alloc_mem, rng );
507 0 : fd_pubkey_pubkey_pair_t_map_insert( self->epoch_authorized_voters_pool, &self->epoch_authorized_voters_root, node );
508 0 : }
509 0 : return mem;
510 0 : }
511 :
512 0 : void *fd_epoch_epoch_stakes_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
513 0 : fd_epoch_epoch_stakes_pair_t *self = (fd_epoch_epoch_stakes_pair_t *) mem;
514 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_epoch_epoch_stakes_pair_t);
515 0 : fd_epoch_epoch_stakes_pair_new(mem);
516 0 : self->key = fd_rng_ulong( rng );
517 0 : fd_epoch_stakes_generate( &self->value, alloc_mem, rng );
518 0 : return mem;
519 0 : }
520 :
521 0 : void *fd_pubkey_u64_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
522 0 : fd_pubkey_u64_pair_t *self = (fd_pubkey_u64_pair_t *) mem;
523 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_u64_pair_t);
524 0 : fd_pubkey_u64_pair_new(mem);
525 0 : fd_pubkey_generate( &self->_0, alloc_mem, rng );
526 0 : self->_1 = fd_rng_ulong( rng );
527 0 : return mem;
528 0 : }
529 :
530 0 : void *fd_unused_accounts_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
531 0 : fd_unused_accounts_t *self = (fd_unused_accounts_t *) mem;
532 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_unused_accounts_t);
533 0 : fd_unused_accounts_new(mem);
534 0 : self->unused1_len = fd_rng_ulong( rng ) % 8;
535 0 : if( self->unused1_len ) {
536 0 : self->unused1 = (fd_pubkey_t *) *alloc_mem;
537 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t)*self->unused1_len;
538 0 : for( ulong i=0; i < self->unused1_len; i++ ) {
539 0 : fd_pubkey_new( self->unused1 + i );
540 0 : fd_pubkey_generate( self->unused1 + i, alloc_mem, rng );
541 0 : }
542 0 : } else {
543 0 : self->unused1 = NULL;
544 0 : }
545 0 : self->unused2_len = fd_rng_ulong( rng ) % 8;
546 0 : if( self->unused2_len ) {
547 0 : self->unused2 = (fd_pubkey_t *) *alloc_mem;
548 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t)*self->unused2_len;
549 0 : for( ulong i=0; i < self->unused2_len; i++ ) {
550 0 : fd_pubkey_new( self->unused2 + i );
551 0 : fd_pubkey_generate( self->unused2 + i, alloc_mem, rng );
552 0 : }
553 0 : } else {
554 0 : self->unused2 = NULL;
555 0 : }
556 0 : self->unused3_len = fd_rng_ulong( rng ) % 8;
557 0 : if( self->unused3_len ) {
558 0 : self->unused3 = (fd_pubkey_u64_pair_t *) *alloc_mem;
559 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_u64_pair_t)*self->unused3_len;
560 0 : for( ulong i=0; i < self->unused3_len; i++ ) {
561 0 : fd_pubkey_u64_pair_new( self->unused3 + i );
562 0 : fd_pubkey_u64_pair_generate( self->unused3 + i, alloc_mem, rng );
563 0 : }
564 0 : } else {
565 0 : self->unused3 = NULL;
566 0 : }
567 0 : return mem;
568 0 : }
569 :
570 0 : void *fd_versioned_bank_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
571 0 : fd_versioned_bank_t *self = (fd_versioned_bank_t *) mem;
572 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_versioned_bank_t);
573 0 : fd_versioned_bank_new(mem);
574 0 : fd_block_hash_vec_generate( &self->blockhash_queue, alloc_mem, rng );
575 0 : self->ancestors_len = fd_rng_ulong( rng ) % 8;
576 0 : if( self->ancestors_len ) {
577 0 : self->ancestors = (fd_slot_pair_t *) *alloc_mem;
578 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_pair_t)*self->ancestors_len;
579 0 : for( ulong i=0; i < self->ancestors_len; i++ ) {
580 0 : fd_slot_pair_new( self->ancestors + i );
581 0 : fd_slot_pair_generate( self->ancestors + i, alloc_mem, rng );
582 0 : }
583 0 : } else {
584 0 : self->ancestors = NULL;
585 0 : }
586 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
587 0 : fd_hash_generate( &self->parent_hash, alloc_mem, rng );
588 0 : self->parent_slot = fd_rng_ulong( rng );
589 0 : fd_hard_forks_generate( &self->hard_forks, alloc_mem, rng );
590 0 : self->transaction_count = fd_rng_ulong( rng );
591 0 : self->tick_height = fd_rng_ulong( rng );
592 0 : self->signature_count = fd_rng_ulong( rng );
593 0 : self->capitalization = fd_rng_ulong( rng );
594 0 : self->max_tick_height = fd_rng_ulong( rng );
595 0 : {
596 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
597 0 : if( !is_null ) {
598 0 : self->hashes_per_tick = (ulong *) *alloc_mem;
599 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong);
600 0 : LLVMFuzzerMutate( (uchar *)self->hashes_per_tick, sizeof(ulong), sizeof(ulong) );
601 0 : }
602 0 : else {
603 0 : self->hashes_per_tick = NULL;
604 0 : }
605 0 : }
606 0 : self->ticks_per_slot = fd_rng_ulong( rng );
607 0 : self->ns_per_slot = fd_rng_uint128( rng );
608 0 : self->genesis_creation_time = fd_rng_ulong( rng );
609 0 : self->slots_per_year = fd_rng_double_o( rng );
610 0 : self->accounts_data_len = fd_rng_ulong( rng );
611 0 : self->slot = fd_rng_ulong( rng );
612 0 : self->epoch = fd_rng_ulong( rng );
613 0 : self->block_height = fd_rng_ulong( rng );
614 0 : fd_pubkey_generate( &self->collector_id, alloc_mem, rng );
615 0 : self->collector_fees = fd_rng_ulong( rng );
616 0 : fd_fee_calculator_generate( &self->fee_calculator, alloc_mem, rng );
617 0 : fd_fee_rate_governor_generate( &self->fee_rate_governor, alloc_mem, rng );
618 0 : self->collected_rent = fd_rng_ulong( rng );
619 0 : fd_rent_collector_generate( &self->rent_collector, alloc_mem, rng );
620 0 : fd_epoch_schedule_generate( &self->epoch_schedule, alloc_mem, rng );
621 0 : fd_inflation_generate( &self->inflation, alloc_mem, rng );
622 0 : fd_stakes_generate( &self->stakes, alloc_mem, rng );
623 0 : fd_unused_accounts_generate( &self->unused_accounts, alloc_mem, rng );
624 0 : self->epoch_stakes_len = fd_rng_ulong( rng ) % 8;
625 0 : if( self->epoch_stakes_len ) {
626 0 : self->epoch_stakes = (fd_epoch_epoch_stakes_pair_t *) *alloc_mem;
627 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_epoch_epoch_stakes_pair_t)*self->epoch_stakes_len;
628 0 : for( ulong i=0; i < self->epoch_stakes_len; i++ ) {
629 0 : fd_epoch_epoch_stakes_pair_new( self->epoch_stakes + i );
630 0 : fd_epoch_epoch_stakes_pair_generate( self->epoch_stakes + i, alloc_mem, rng );
631 0 : }
632 0 : } else {
633 0 : self->epoch_stakes = NULL;
634 0 : }
635 0 : self->is_delta = fd_rng_uchar( rng );
636 0 : return mem;
637 0 : }
638 :
639 0 : void *fd_bank_hash_stats_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
640 0 : fd_bank_hash_stats_t *self = (fd_bank_hash_stats_t *) mem;
641 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bank_hash_stats_t);
642 0 : fd_bank_hash_stats_new(mem);
643 0 : self->num_updated_accounts = fd_rng_ulong( rng );
644 0 : self->num_removed_accounts = fd_rng_ulong( rng );
645 0 : self->num_lamports_stored = fd_rng_ulong( rng );
646 0 : self->total_data_len = fd_rng_ulong( rng );
647 0 : self->num_executable_accounts = fd_rng_ulong( rng );
648 0 : return mem;
649 0 : }
650 :
651 0 : void *fd_bank_hash_info_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
652 0 : fd_bank_hash_info_t *self = (fd_bank_hash_info_t *) mem;
653 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bank_hash_info_t);
654 0 : fd_bank_hash_info_new(mem);
655 0 : fd_hash_generate( &self->accounts_delta_hash, alloc_mem, rng );
656 0 : fd_hash_generate( &self->accounts_hash, alloc_mem, rng );
657 0 : fd_bank_hash_stats_generate( &self->stats, alloc_mem, rng );
658 0 : return mem;
659 0 : }
660 :
661 0 : void *fd_slot_map_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
662 0 : fd_slot_map_pair_t *self = (fd_slot_map_pair_t *) mem;
663 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_map_pair_t);
664 0 : fd_slot_map_pair_new(mem);
665 0 : self->slot = fd_rng_ulong( rng );
666 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
667 0 : return mem;
668 0 : }
669 :
670 0 : void *fd_snapshot_acc_vec_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
671 0 : fd_snapshot_acc_vec_t *self = (fd_snapshot_acc_vec_t *) mem;
672 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_snapshot_acc_vec_t);
673 0 : fd_snapshot_acc_vec_new(mem);
674 0 : self->id = fd_rng_ulong( rng );
675 0 : self->file_sz = fd_rng_ulong( rng );
676 0 : return mem;
677 0 : }
678 :
679 0 : void *fd_snapshot_slot_acc_vecs_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
680 0 : fd_snapshot_slot_acc_vecs_t *self = (fd_snapshot_slot_acc_vecs_t *) mem;
681 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_snapshot_slot_acc_vecs_t);
682 0 : fd_snapshot_slot_acc_vecs_new(mem);
683 0 : self->slot = fd_rng_ulong( rng );
684 0 : self->account_vecs_len = fd_rng_ulong( rng ) % 8;
685 0 : if( self->account_vecs_len ) {
686 0 : self->account_vecs = (fd_snapshot_acc_vec_t *) *alloc_mem;
687 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_snapshot_acc_vec_t)*self->account_vecs_len;
688 0 : for( ulong i=0; i < self->account_vecs_len; i++ ) {
689 0 : fd_snapshot_acc_vec_new( self->account_vecs + i );
690 0 : fd_snapshot_acc_vec_generate( self->account_vecs + i, alloc_mem, rng );
691 0 : }
692 0 : } else {
693 0 : self->account_vecs = NULL;
694 0 : }
695 0 : return mem;
696 0 : }
697 :
698 0 : void *fd_reward_type_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
699 0 : fd_reward_type_t *self = (fd_reward_type_t *) mem;
700 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_reward_type_t);
701 0 : fd_reward_type_new(mem);
702 0 : self->discriminant = fd_rng_uint( rng ) % 4;
703 0 : return mem;
704 0 : }
705 :
706 0 : void *fd_solana_accounts_db_fields_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
707 0 : fd_solana_accounts_db_fields_t *self = (fd_solana_accounts_db_fields_t *) mem;
708 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_solana_accounts_db_fields_t);
709 0 : fd_solana_accounts_db_fields_new(mem);
710 0 : self->storages_len = fd_rng_ulong( rng ) % 8;
711 0 : if( self->storages_len ) {
712 0 : self->storages = (fd_snapshot_slot_acc_vecs_t *) *alloc_mem;
713 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_snapshot_slot_acc_vecs_t)*self->storages_len;
714 0 : for( ulong i=0; i < self->storages_len; i++ ) {
715 0 : fd_snapshot_slot_acc_vecs_new( self->storages + i );
716 0 : fd_snapshot_slot_acc_vecs_generate( self->storages + i, alloc_mem, rng );
717 0 : }
718 0 : } else {
719 0 : self->storages = NULL;
720 0 : }
721 0 : self->version = fd_rng_ulong( rng );
722 0 : self->slot = fd_rng_ulong( rng );
723 0 : fd_bank_hash_info_generate( &self->bank_hash_info, alloc_mem, rng );
724 0 : self->historical_roots_len = fd_rng_ulong( rng ) % 8;
725 0 : if( self->historical_roots_len ) {
726 0 : self->historical_roots = (ulong *) *alloc_mem;
727 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong)*self->historical_roots_len;
728 0 : LLVMFuzzerMutate( (uchar *) self->historical_roots, sizeof(ulong)*self->historical_roots_len, sizeof(ulong)*self->historical_roots_len );
729 0 : } else {
730 0 : self->historical_roots = NULL;
731 0 : }
732 0 : self->historical_roots_with_hash_len = fd_rng_ulong( rng ) % 8;
733 0 : if( self->historical_roots_with_hash_len ) {
734 0 : self->historical_roots_with_hash = (fd_slot_map_pair_t *) *alloc_mem;
735 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_map_pair_t)*self->historical_roots_with_hash_len;
736 0 : for( ulong i=0; i < self->historical_roots_with_hash_len; i++ ) {
737 0 : fd_slot_map_pair_new( self->historical_roots_with_hash + i );
738 0 : fd_slot_map_pair_generate( self->historical_roots_with_hash + i, alloc_mem, rng );
739 0 : }
740 0 : } else {
741 0 : self->historical_roots_with_hash = NULL;
742 0 : }
743 0 : return mem;
744 0 : }
745 :
746 0 : void *fd_versioned_epoch_stakes_current_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
747 0 : fd_versioned_epoch_stakes_current_t *self = (fd_versioned_epoch_stakes_current_t *) mem;
748 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_versioned_epoch_stakes_current_t);
749 0 : fd_versioned_epoch_stakes_current_new(mem);
750 0 : fd_stakes_stake_generate( &self->stakes, alloc_mem, rng );
751 0 : self->total_stake = fd_rng_ulong( rng );
752 0 : ulong node_id_to_vote_accounts_len = fd_rng_ulong( rng ) % 8;
753 0 : self->node_id_to_vote_accounts_pool = fd_pubkey_node_vote_accounts_pair_t_map_join_new( alloc_mem, node_id_to_vote_accounts_len );
754 0 : self->node_id_to_vote_accounts_root = NULL;
755 0 : for( ulong i=0; i < node_id_to_vote_accounts_len; i++ ) {
756 0 : fd_pubkey_node_vote_accounts_pair_t_mapnode_t * node = fd_pubkey_node_vote_accounts_pair_t_map_acquire( self->node_id_to_vote_accounts_pool );
757 0 : fd_pubkey_node_vote_accounts_pair_generate( &node->elem, alloc_mem, rng );
758 0 : fd_pubkey_node_vote_accounts_pair_t_map_insert( self->node_id_to_vote_accounts_pool, &self->node_id_to_vote_accounts_root, node );
759 0 : }
760 0 : ulong epoch_authorized_voters_len = fd_rng_ulong( rng ) % 8;
761 0 : self->epoch_authorized_voters_pool = fd_pubkey_pubkey_pair_t_map_join_new( alloc_mem, epoch_authorized_voters_len );
762 0 : self->epoch_authorized_voters_root = NULL;
763 0 : for( ulong i=0; i < epoch_authorized_voters_len; i++ ) {
764 0 : fd_pubkey_pubkey_pair_t_mapnode_t * node = fd_pubkey_pubkey_pair_t_map_acquire( self->epoch_authorized_voters_pool );
765 0 : fd_pubkey_pubkey_pair_generate( &node->elem, alloc_mem, rng );
766 0 : fd_pubkey_pubkey_pair_t_map_insert( self->epoch_authorized_voters_pool, &self->epoch_authorized_voters_root, node );
767 0 : }
768 0 : return mem;
769 0 : }
770 :
771 0 : void fd_versioned_epoch_stakes_inner_generate( fd_versioned_epoch_stakes_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
772 0 : switch (discriminant) {
773 0 : case 0: {
774 0 : fd_versioned_epoch_stakes_current_generate( &self->Current, alloc_mem, rng );
775 0 : break;
776 0 : }
777 0 : }
778 0 : }
779 0 : void *fd_versioned_epoch_stakes_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
780 0 : fd_versioned_epoch_stakes_t *self = (fd_versioned_epoch_stakes_t *) mem;
781 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_versioned_epoch_stakes_t);
782 0 : fd_versioned_epoch_stakes_new(mem);
783 0 : self->discriminant = fd_rng_uint( rng ) % 1;
784 0 : fd_versioned_epoch_stakes_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
785 0 : return mem;
786 0 : }
787 :
788 0 : void *fd_versioned_epoch_stakes_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
789 0 : fd_versioned_epoch_stakes_pair_t *self = (fd_versioned_epoch_stakes_pair_t *) mem;
790 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_versioned_epoch_stakes_pair_t);
791 0 : fd_versioned_epoch_stakes_pair_new(mem);
792 0 : self->epoch = fd_rng_ulong( rng );
793 0 : fd_versioned_epoch_stakes_generate( &self->val, alloc_mem, rng );
794 0 : return mem;
795 0 : }
796 :
797 0 : void *fd_reward_info_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
798 0 : fd_reward_info_t *self = (fd_reward_info_t *) mem;
799 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_reward_info_t);
800 0 : fd_reward_info_new(mem);
801 0 : fd_reward_type_generate( &self->reward_type, alloc_mem, rng );
802 0 : self->lamports = fd_rng_ulong( rng );
803 0 : self->post_balance = fd_rng_ulong( rng );
804 0 : self->commission = fd_rng_ulong( rng );
805 0 : return mem;
806 0 : }
807 :
808 0 : void *fd_slot_lthash_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
809 0 : fd_slot_lthash_t *self = (fd_slot_lthash_t *) mem;
810 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_lthash_t);
811 0 : fd_slot_lthash_new(mem);
812 0 : LLVMFuzzerMutate( &self->lthash[0], sizeof(self->lthash), sizeof(self->lthash) );
813 0 : return mem;
814 0 : }
815 :
816 0 : void *fd_solana_manifest_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
817 0 : fd_solana_manifest_t *self = (fd_solana_manifest_t *) mem;
818 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_solana_manifest_t);
819 0 : fd_solana_manifest_new(mem);
820 0 : fd_versioned_bank_generate( &self->bank, alloc_mem, rng );
821 0 : fd_solana_accounts_db_fields_generate( &self->accounts_db, alloc_mem, rng );
822 0 : self->lamports_per_signature = fd_rng_ulong( rng );
823 0 : {
824 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
825 0 : if( !is_null ) {
826 0 : self->bank_incremental_snapshot_persistence = (fd_bank_incremental_snapshot_persistence_t *) *alloc_mem;
827 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bank_incremental_snapshot_persistence_t);
828 0 : fd_bank_incremental_snapshot_persistence_new( self->bank_incremental_snapshot_persistence );
829 0 : fd_bank_incremental_snapshot_persistence_generate( self->bank_incremental_snapshot_persistence, alloc_mem, rng );
830 0 : }
831 0 : else {
832 0 : self->bank_incremental_snapshot_persistence = NULL;
833 0 : }
834 0 : }
835 0 : {
836 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
837 0 : if( !is_null ) {
838 0 : self->epoch_account_hash = (fd_hash_t *) *alloc_mem;
839 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_hash_t);
840 0 : fd_hash_new( self->epoch_account_hash );
841 0 : fd_hash_generate( self->epoch_account_hash, alloc_mem, rng );
842 0 : }
843 0 : else {
844 0 : self->epoch_account_hash = NULL;
845 0 : }
846 0 : }
847 0 : self->versioned_epoch_stakes_len = fd_rng_ulong( rng ) % 8;
848 0 : if( self->versioned_epoch_stakes_len ) {
849 0 : self->versioned_epoch_stakes = (fd_versioned_epoch_stakes_pair_t *) *alloc_mem;
850 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_versioned_epoch_stakes_pair_t)*self->versioned_epoch_stakes_len;
851 0 : for( ulong i=0; i < self->versioned_epoch_stakes_len; i++ ) {
852 0 : fd_versioned_epoch_stakes_pair_new( self->versioned_epoch_stakes + i );
853 0 : fd_versioned_epoch_stakes_pair_generate( self->versioned_epoch_stakes + i, alloc_mem, rng );
854 0 : }
855 0 : } else {
856 0 : self->versioned_epoch_stakes = NULL;
857 0 : }
858 0 : {
859 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
860 0 : if( !is_null ) {
861 0 : self->lthash = (fd_slot_lthash_t *) *alloc_mem;
862 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_lthash_t);
863 0 : fd_slot_lthash_new( self->lthash );
864 0 : fd_slot_lthash_generate( self->lthash, alloc_mem, rng );
865 0 : }
866 0 : else {
867 0 : self->lthash = NULL;
868 0 : }
869 0 : }
870 0 : return mem;
871 0 : }
872 :
873 0 : void *fd_rust_duration_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
874 0 : fd_rust_duration_t *self = (fd_rust_duration_t *) mem;
875 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_rust_duration_t);
876 0 : fd_rust_duration_new(mem);
877 0 : self->seconds = fd_rng_ulong( rng );
878 0 : self->nanoseconds = fd_rng_uint( rng );
879 0 : return mem;
880 0 : }
881 :
882 0 : void *fd_poh_config_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
883 0 : fd_poh_config_t *self = (fd_poh_config_t *) mem;
884 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_poh_config_t);
885 0 : fd_poh_config_new(mem);
886 0 : fd_rust_duration_generate( &self->target_tick_duration, alloc_mem, rng );
887 0 : {
888 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
889 0 : if( !is_null ) {
890 0 : self->target_tick_count = (ulong *) *alloc_mem;
891 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong);
892 0 : LLVMFuzzerMutate( (uchar *)self->target_tick_count, sizeof(ulong), sizeof(ulong) );
893 0 : }
894 0 : else {
895 0 : self->target_tick_count = NULL;
896 0 : }
897 0 : }
898 0 : {
899 0 : self->has_hashes_per_tick = fd_rng_uchar( rng ) % 2;
900 0 : if( self->has_hashes_per_tick ) {
901 0 : LLVMFuzzerMutate( (uchar *)&(self->hashes_per_tick), sizeof(ulong), sizeof(ulong) );
902 0 : }
903 0 : }
904 0 : return mem;
905 0 : }
906 :
907 0 : void *fd_string_pubkey_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
908 0 : fd_string_pubkey_pair_t *self = (fd_string_pubkey_pair_t *) mem;
909 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_string_pubkey_pair_t);
910 0 : fd_string_pubkey_pair_new(mem);
911 0 : self->string_len = fd_rng_ulong( rng ) % 8;
912 0 : if( self->string_len ) {
913 0 : self->string = (uchar *) *alloc_mem;
914 0 : *alloc_mem = (uchar *) *alloc_mem + self->string_len;
915 0 : for( ulong i=0; i < self->string_len; ++i) { self->string[i] = fd_rng_uchar( rng ) % 0x80; }
916 0 : } else {
917 0 : self->string = NULL;
918 0 : }
919 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
920 0 : return mem;
921 0 : }
922 :
923 0 : void *fd_pubkey_account_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
924 0 : fd_pubkey_account_pair_t *self = (fd_pubkey_account_pair_t *) mem;
925 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_account_pair_t);
926 0 : fd_pubkey_account_pair_new(mem);
927 0 : fd_pubkey_generate( &self->key, alloc_mem, rng );
928 0 : fd_solana_account_generate( &self->account, alloc_mem, rng );
929 0 : return mem;
930 0 : }
931 :
932 0 : void *fd_genesis_solana_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
933 0 : fd_genesis_solana_t *self = (fd_genesis_solana_t *) mem;
934 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_genesis_solana_t);
935 0 : fd_genesis_solana_new(mem);
936 0 : self->creation_time = fd_rng_ulong( rng );
937 0 : self->accounts_len = fd_rng_ulong( rng ) % 8;
938 0 : if( self->accounts_len ) {
939 0 : self->accounts = (fd_pubkey_account_pair_t *) *alloc_mem;
940 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_account_pair_t)*self->accounts_len;
941 0 : for( ulong i=0; i < self->accounts_len; i++ ) {
942 0 : fd_pubkey_account_pair_new( self->accounts + i );
943 0 : fd_pubkey_account_pair_generate( self->accounts + i, alloc_mem, rng );
944 0 : }
945 0 : } else {
946 0 : self->accounts = NULL;
947 0 : }
948 0 : self->native_instruction_processors_len = fd_rng_ulong( rng ) % 8;
949 0 : if( self->native_instruction_processors_len ) {
950 0 : self->native_instruction_processors = (fd_string_pubkey_pair_t *) *alloc_mem;
951 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_string_pubkey_pair_t)*self->native_instruction_processors_len;
952 0 : for( ulong i=0; i < self->native_instruction_processors_len; i++ ) {
953 0 : fd_string_pubkey_pair_new( self->native_instruction_processors + i );
954 0 : fd_string_pubkey_pair_generate( self->native_instruction_processors + i, alloc_mem, rng );
955 0 : }
956 0 : } else {
957 0 : self->native_instruction_processors = NULL;
958 0 : }
959 0 : self->rewards_pools_len = fd_rng_ulong( rng ) % 8;
960 0 : if( self->rewards_pools_len ) {
961 0 : self->rewards_pools = (fd_pubkey_account_pair_t *) *alloc_mem;
962 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_account_pair_t)*self->rewards_pools_len;
963 0 : for( ulong i=0; i < self->rewards_pools_len; i++ ) {
964 0 : fd_pubkey_account_pair_new( self->rewards_pools + i );
965 0 : fd_pubkey_account_pair_generate( self->rewards_pools + i, alloc_mem, rng );
966 0 : }
967 0 : } else {
968 0 : self->rewards_pools = NULL;
969 0 : }
970 0 : self->ticks_per_slot = fd_rng_ulong( rng );
971 0 : self->unused = fd_rng_ulong( rng );
972 0 : fd_poh_config_generate( &self->poh_config, alloc_mem, rng );
973 0 : self->__backwards_compat_with_v0_23 = fd_rng_ulong( rng );
974 0 : fd_fee_rate_governor_generate( &self->fee_rate_governor, alloc_mem, rng );
975 0 : fd_rent_generate( &self->rent, alloc_mem, rng );
976 0 : fd_inflation_generate( &self->inflation, alloc_mem, rng );
977 0 : fd_epoch_schedule_generate( &self->epoch_schedule, alloc_mem, rng );
978 0 : self->cluster_type = fd_rng_uint( rng );
979 0 : return mem;
980 0 : }
981 :
982 0 : void *fd_sol_sysvar_clock_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
983 0 : fd_sol_sysvar_clock_t *self = (fd_sol_sysvar_clock_t *) mem;
984 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_sol_sysvar_clock_t);
985 0 : fd_sol_sysvar_clock_new(mem);
986 0 : self->slot = fd_rng_ulong( rng );
987 0 : self->epoch_start_timestamp = fd_rng_long( rng );
988 0 : self->epoch = fd_rng_ulong( rng );
989 0 : self->leader_schedule_epoch = fd_rng_ulong( rng );
990 0 : self->unix_timestamp = fd_rng_long( rng );
991 0 : return mem;
992 0 : }
993 :
994 0 : void *fd_sol_sysvar_last_restart_slot_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
995 0 : fd_sol_sysvar_last_restart_slot_t *self = (fd_sol_sysvar_last_restart_slot_t *) mem;
996 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_sol_sysvar_last_restart_slot_t);
997 0 : fd_sol_sysvar_last_restart_slot_new(mem);
998 0 : self->slot = fd_rng_ulong( rng );
999 0 : return mem;
1000 0 : }
1001 :
1002 0 : void *fd_vote_lockout_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1003 0 : fd_vote_lockout_t *self = (fd_vote_lockout_t *) mem;
1004 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_lockout_t);
1005 0 : fd_vote_lockout_new(mem);
1006 0 : self->slot = fd_rng_ulong( rng );
1007 0 : self->confirmation_count = fd_rng_uint( rng );
1008 0 : return mem;
1009 0 : }
1010 :
1011 0 : void *fd_lockout_offset_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1012 0 : fd_lockout_offset_t *self = (fd_lockout_offset_t *) mem;
1013 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_lockout_offset_t);
1014 0 : fd_lockout_offset_new(mem);
1015 0 : self->offset = fd_rng_ulong( rng );
1016 0 : self->confirmation_count = fd_rng_uchar( rng );
1017 0 : return mem;
1018 0 : }
1019 :
1020 0 : void *fd_vote_authorized_voter_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1021 0 : fd_vote_authorized_voter_t *self = (fd_vote_authorized_voter_t *) mem;
1022 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_authorized_voter_t);
1023 0 : fd_vote_authorized_voter_new(mem);
1024 0 : self->epoch = fd_rng_ulong( rng );
1025 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
1026 0 : self->parent = fd_rng_ulong( rng );
1027 0 : self->left = fd_rng_ulong( rng );
1028 0 : self->right = fd_rng_ulong( rng );
1029 0 : self->prio = fd_rng_ulong( rng );
1030 0 : return mem;
1031 0 : }
1032 :
1033 0 : void *fd_vote_prior_voter_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1034 0 : fd_vote_prior_voter_t *self = (fd_vote_prior_voter_t *) mem;
1035 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_prior_voter_t);
1036 0 : fd_vote_prior_voter_new(mem);
1037 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
1038 0 : self->epoch_start = fd_rng_ulong( rng );
1039 0 : self->epoch_end = fd_rng_ulong( rng );
1040 0 : return mem;
1041 0 : }
1042 :
1043 0 : void *fd_vote_prior_voter_0_23_5_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1044 0 : fd_vote_prior_voter_0_23_5_t *self = (fd_vote_prior_voter_0_23_5_t *) mem;
1045 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_prior_voter_0_23_5_t);
1046 0 : fd_vote_prior_voter_0_23_5_new(mem);
1047 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
1048 0 : self->epoch_start = fd_rng_ulong( rng );
1049 0 : self->epoch_end = fd_rng_ulong( rng );
1050 0 : self->slot = fd_rng_ulong( rng );
1051 0 : return mem;
1052 0 : }
1053 :
1054 0 : void *fd_vote_epoch_credits_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1055 0 : fd_vote_epoch_credits_t *self = (fd_vote_epoch_credits_t *) mem;
1056 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_epoch_credits_t);
1057 0 : fd_vote_epoch_credits_new(mem);
1058 0 : self->epoch = fd_rng_ulong( rng );
1059 0 : self->credits = fd_rng_ulong( rng );
1060 0 : self->prev_credits = fd_rng_ulong( rng );
1061 0 : return mem;
1062 0 : }
1063 :
1064 0 : void *fd_vote_block_timestamp_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1065 0 : fd_vote_block_timestamp_t *self = (fd_vote_block_timestamp_t *) mem;
1066 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_block_timestamp_t);
1067 0 : fd_vote_block_timestamp_new(mem);
1068 0 : self->slot = fd_rng_ulong( rng );
1069 0 : self->timestamp = fd_rng_long( rng );
1070 0 : return mem;
1071 0 : }
1072 :
1073 0 : void *fd_vote_prior_voters_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1074 0 : fd_vote_prior_voters_t *self = (fd_vote_prior_voters_t *) mem;
1075 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_prior_voters_t);
1076 0 : fd_vote_prior_voters_new(mem);
1077 0 : for( ulong i=0; i<32; i++ ) {
1078 0 : fd_vote_prior_voter_generate( self->buf + i, alloc_mem, rng );
1079 0 : }
1080 0 : self->idx = fd_rng_ulong( rng );
1081 0 : self->is_empty = fd_rng_uchar( rng );
1082 0 : return mem;
1083 0 : }
1084 :
1085 0 : void *fd_vote_prior_voters_0_23_5_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1086 0 : fd_vote_prior_voters_0_23_5_t *self = (fd_vote_prior_voters_0_23_5_t *) mem;
1087 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_prior_voters_0_23_5_t);
1088 0 : fd_vote_prior_voters_0_23_5_new(mem);
1089 0 : for( ulong i=0; i<32; i++ ) {
1090 0 : fd_vote_prior_voter_0_23_5_generate( self->buf + i, alloc_mem, rng );
1091 0 : }
1092 0 : self->idx = fd_rng_ulong( rng );
1093 0 : return mem;
1094 0 : }
1095 :
1096 0 : void *fd_landed_vote_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1097 0 : fd_landed_vote_t *self = (fd_landed_vote_t *) mem;
1098 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_landed_vote_t);
1099 0 : fd_landed_vote_new(mem);
1100 0 : self->latency = fd_rng_uchar( rng );
1101 0 : fd_vote_lockout_generate( &self->lockout, alloc_mem, rng );
1102 0 : return mem;
1103 0 : }
1104 :
1105 0 : void *fd_vote_state_0_23_5_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1106 0 : fd_vote_state_0_23_5_t *self = (fd_vote_state_0_23_5_t *) mem;
1107 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_state_0_23_5_t);
1108 0 : fd_vote_state_0_23_5_new(mem);
1109 0 : fd_pubkey_generate( &self->node_pubkey, alloc_mem, rng );
1110 0 : fd_pubkey_generate( &self->authorized_voter, alloc_mem, rng );
1111 0 : self->authorized_voter_epoch = fd_rng_ulong( rng );
1112 0 : fd_vote_prior_voters_0_23_5_generate( &self->prior_voters, alloc_mem, rng );
1113 0 : fd_pubkey_generate( &self->authorized_withdrawer, alloc_mem, rng );
1114 0 : self->commission = fd_rng_uchar( rng );
1115 0 : ulong votes_len = fd_rng_ulong( rng ) % 8;
1116 0 : ulong votes_max = fd_ulong_max( votes_len, 32 );
1117 0 : self->votes = deq_fd_vote_lockout_t_join_new( alloc_mem, votes_max );
1118 0 : for( ulong i=0; i < votes_len; i++ ) {
1119 0 : fd_vote_lockout_t * elem = deq_fd_vote_lockout_t_push_tail_nocopy( self->votes );
1120 0 : fd_vote_lockout_generate( elem, alloc_mem, rng );
1121 0 : }
1122 0 : {
1123 0 : self->has_root_slot = fd_rng_uchar( rng ) % 2;
1124 0 : if( self->has_root_slot ) {
1125 0 : LLVMFuzzerMutate( (uchar *)&(self->root_slot), sizeof(ulong), sizeof(ulong) );
1126 0 : }
1127 0 : }
1128 0 : ulong epoch_credits_len = fd_rng_ulong( rng ) % 8;
1129 0 : ulong epoch_credits_max = fd_ulong_max( epoch_credits_len, 64 );
1130 0 : self->epoch_credits = deq_fd_vote_epoch_credits_t_join_new( alloc_mem, epoch_credits_max );
1131 0 : for( ulong i=0; i < epoch_credits_len; i++ ) {
1132 0 : fd_vote_epoch_credits_t * elem = deq_fd_vote_epoch_credits_t_push_tail_nocopy( self->epoch_credits );
1133 0 : fd_vote_epoch_credits_generate( elem, alloc_mem, rng );
1134 0 : }
1135 0 : fd_vote_block_timestamp_generate( &self->last_timestamp, alloc_mem, rng );
1136 0 : return mem;
1137 0 : }
1138 :
1139 0 : void *fd_vote_authorized_voters_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1140 0 : fd_vote_authorized_voters_t *self = (fd_vote_authorized_voters_t *) mem;
1141 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_authorized_voters_t);
1142 0 : fd_vote_authorized_voters_new(mem);
1143 0 : ulong fd_vote_authorized_voters_treap_len = fd_rng_ulong( rng ) % 8;
1144 0 : ulong fd_vote_authorized_voters_treap_max = fd_ulong_max( fd_vote_authorized_voters_treap_len, FD_VOTE_AUTHORIZED_VOTERS_MIN );
1145 0 : self->pool = fd_vote_authorized_voters_pool_join_new( alloc_mem, fd_vote_authorized_voters_treap_max );
1146 0 : self->treap = fd_vote_authorized_voters_treap_join_new( alloc_mem, fd_vote_authorized_voters_treap_max );
1147 0 : for( ulong i=0; i < fd_vote_authorized_voters_treap_len; i++ ) {
1148 0 : fd_vote_authorized_voter_t * ele = fd_vote_authorized_voters_pool_ele_acquire( self->pool );
1149 0 : fd_vote_authorized_voter_generate( ele, alloc_mem, rng );
1150 0 : fd_vote_authorized_voter_t * repeated_entry = fd_vote_authorized_voters_treap_ele_query( self->treap, ele->epoch, self->pool );
1151 0 : if( repeated_entry ) {
1152 0 : fd_vote_authorized_voters_treap_ele_remove( self->treap, repeated_entry, self->pool ); // Remove the element before inserting it back to avoid duplication
1153 0 : fd_vote_authorized_voters_pool_ele_release( self->pool, repeated_entry );
1154 0 : }
1155 0 : fd_vote_authorized_voters_treap_ele_insert( self->treap, ele, self->pool ); /* this cannot fail */
1156 0 : }
1157 0 : return mem;
1158 0 : }
1159 :
1160 0 : void *fd_vote_state_1_14_11_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1161 0 : fd_vote_state_1_14_11_t *self = (fd_vote_state_1_14_11_t *) mem;
1162 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_state_1_14_11_t);
1163 0 : fd_vote_state_1_14_11_new(mem);
1164 0 : fd_pubkey_generate( &self->node_pubkey, alloc_mem, rng );
1165 0 : fd_pubkey_generate( &self->authorized_withdrawer, alloc_mem, rng );
1166 0 : self->commission = fd_rng_uchar( rng );
1167 0 : ulong votes_len = fd_rng_ulong( rng ) % 8;
1168 0 : ulong votes_max = fd_ulong_max( votes_len, 32 );
1169 0 : self->votes = deq_fd_vote_lockout_t_join_new( alloc_mem, votes_max );
1170 0 : for( ulong i=0; i < votes_len; i++ ) {
1171 0 : fd_vote_lockout_t * elem = deq_fd_vote_lockout_t_push_tail_nocopy( self->votes );
1172 0 : fd_vote_lockout_generate( elem, alloc_mem, rng );
1173 0 : }
1174 0 : {
1175 0 : self->has_root_slot = fd_rng_uchar( rng ) % 2;
1176 0 : if( self->has_root_slot ) {
1177 0 : LLVMFuzzerMutate( (uchar *)&(self->root_slot), sizeof(ulong), sizeof(ulong) );
1178 0 : }
1179 0 : }
1180 0 : fd_vote_authorized_voters_generate( &self->authorized_voters, alloc_mem, rng );
1181 0 : fd_vote_prior_voters_generate( &self->prior_voters, alloc_mem, rng );
1182 0 : ulong epoch_credits_len = fd_rng_ulong( rng ) % 8;
1183 0 : ulong epoch_credits_max = fd_ulong_max( epoch_credits_len, 64 );
1184 0 : self->epoch_credits = deq_fd_vote_epoch_credits_t_join_new( alloc_mem, epoch_credits_max );
1185 0 : for( ulong i=0; i < epoch_credits_len; i++ ) {
1186 0 : fd_vote_epoch_credits_t * elem = deq_fd_vote_epoch_credits_t_push_tail_nocopy( self->epoch_credits );
1187 0 : fd_vote_epoch_credits_generate( elem, alloc_mem, rng );
1188 0 : }
1189 0 : fd_vote_block_timestamp_generate( &self->last_timestamp, alloc_mem, rng );
1190 0 : return mem;
1191 0 : }
1192 :
1193 0 : void *fd_vote_state_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1194 0 : fd_vote_state_t *self = (fd_vote_state_t *) mem;
1195 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_state_t);
1196 0 : fd_vote_state_new(mem);
1197 0 : fd_pubkey_generate( &self->node_pubkey, alloc_mem, rng );
1198 0 : fd_pubkey_generate( &self->authorized_withdrawer, alloc_mem, rng );
1199 0 : self->commission = fd_rng_uchar( rng );
1200 0 : ulong votes_len = fd_rng_ulong( rng ) % 8;
1201 0 : ulong votes_max = fd_ulong_max( votes_len, 32 );
1202 0 : self->votes = deq_fd_landed_vote_t_join_new( alloc_mem, votes_max );
1203 0 : for( ulong i=0; i < votes_len; i++ ) {
1204 0 : fd_landed_vote_t * elem = deq_fd_landed_vote_t_push_tail_nocopy( self->votes );
1205 0 : fd_landed_vote_generate( elem, alloc_mem, rng );
1206 0 : }
1207 0 : {
1208 0 : self->has_root_slot = fd_rng_uchar( rng ) % 2;
1209 0 : if( self->has_root_slot ) {
1210 0 : LLVMFuzzerMutate( (uchar *)&(self->root_slot), sizeof(ulong), sizeof(ulong) );
1211 0 : }
1212 0 : }
1213 0 : fd_vote_authorized_voters_generate( &self->authorized_voters, alloc_mem, rng );
1214 0 : fd_vote_prior_voters_generate( &self->prior_voters, alloc_mem, rng );
1215 0 : ulong epoch_credits_len = fd_rng_ulong( rng ) % 8;
1216 0 : ulong epoch_credits_max = fd_ulong_max( epoch_credits_len, 64 );
1217 0 : self->epoch_credits = deq_fd_vote_epoch_credits_t_join_new( alloc_mem, epoch_credits_max );
1218 0 : for( ulong i=0; i < epoch_credits_len; i++ ) {
1219 0 : fd_vote_epoch_credits_t * elem = deq_fd_vote_epoch_credits_t_push_tail_nocopy( self->epoch_credits );
1220 0 : fd_vote_epoch_credits_generate( elem, alloc_mem, rng );
1221 0 : }
1222 0 : fd_vote_block_timestamp_generate( &self->last_timestamp, alloc_mem, rng );
1223 0 : return mem;
1224 0 : }
1225 :
1226 0 : void fd_vote_state_versioned_inner_generate( fd_vote_state_versioned_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
1227 0 : switch (discriminant) {
1228 0 : case 0: {
1229 0 : fd_vote_state_0_23_5_generate( &self->v0_23_5, alloc_mem, rng );
1230 0 : break;
1231 0 : }
1232 0 : case 1: {
1233 0 : fd_vote_state_1_14_11_generate( &self->v1_14_11, alloc_mem, rng );
1234 0 : break;
1235 0 : }
1236 0 : case 2: {
1237 0 : fd_vote_state_generate( &self->current, alloc_mem, rng );
1238 0 : break;
1239 0 : }
1240 0 : }
1241 0 : }
1242 0 : void *fd_vote_state_versioned_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1243 0 : fd_vote_state_versioned_t *self = (fd_vote_state_versioned_t *) mem;
1244 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_state_versioned_t);
1245 0 : fd_vote_state_versioned_new(mem);
1246 0 : self->discriminant = fd_rng_uint( rng ) % 3;
1247 0 : fd_vote_state_versioned_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1248 0 : return mem;
1249 0 : }
1250 :
1251 0 : void *fd_vote_state_update_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1252 0 : fd_vote_state_update_t *self = (fd_vote_state_update_t *) mem;
1253 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_state_update_t);
1254 0 : fd_vote_state_update_new(mem);
1255 0 : ulong lockouts_len = fd_rng_ulong( rng ) % 8;
1256 0 : ulong lockouts_max = fd_ulong_max( lockouts_len, 32 );
1257 0 : self->lockouts = deq_fd_vote_lockout_t_join_new( alloc_mem, lockouts_max );
1258 0 : for( ulong i=0; i < lockouts_len; i++ ) {
1259 0 : fd_vote_lockout_t * elem = deq_fd_vote_lockout_t_push_tail_nocopy( self->lockouts );
1260 0 : fd_vote_lockout_generate( elem, alloc_mem, rng );
1261 0 : }
1262 0 : {
1263 0 : self->has_root = fd_rng_uchar( rng ) % 2;
1264 0 : if( self->has_root ) {
1265 0 : LLVMFuzzerMutate( (uchar *)&(self->root), sizeof(ulong), sizeof(ulong) );
1266 0 : }
1267 0 : }
1268 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
1269 0 : {
1270 0 : self->has_timestamp = fd_rng_uchar( rng ) % 2;
1271 0 : if( self->has_timestamp ) {
1272 0 : LLVMFuzzerMutate( (uchar *)&(self->timestamp), sizeof(long), sizeof(long) );
1273 0 : }
1274 0 : }
1275 0 : return mem;
1276 0 : }
1277 :
1278 0 : void *fd_compact_vote_state_update_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1279 0 : fd_compact_vote_state_update_t *self = (fd_compact_vote_state_update_t *) mem;
1280 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_compact_vote_state_update_t);
1281 0 : fd_compact_vote_state_update_new(mem);
1282 0 : self->root = fd_rng_ulong( rng );
1283 0 : self->lockouts_len = fd_rng_ulong( rng ) % 8;
1284 0 : if( self->lockouts_len ) {
1285 0 : self->lockouts = (fd_lockout_offset_t *) *alloc_mem;
1286 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_lockout_offset_t)*self->lockouts_len;
1287 0 : for( ulong i=0; i < self->lockouts_len; i++ ) {
1288 0 : fd_lockout_offset_new( self->lockouts + i );
1289 0 : fd_lockout_offset_generate( self->lockouts + i, alloc_mem, rng );
1290 0 : }
1291 0 : } else {
1292 0 : self->lockouts = NULL;
1293 0 : }
1294 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
1295 0 : {
1296 0 : self->has_timestamp = fd_rng_uchar( rng ) % 2;
1297 0 : if( self->has_timestamp ) {
1298 0 : LLVMFuzzerMutate( (uchar *)&(self->timestamp), sizeof(long), sizeof(long) );
1299 0 : }
1300 0 : }
1301 0 : return mem;
1302 0 : }
1303 :
1304 0 : void *fd_compact_vote_state_update_switch_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1305 0 : fd_compact_vote_state_update_switch_t *self = (fd_compact_vote_state_update_switch_t *) mem;
1306 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_compact_vote_state_update_switch_t);
1307 0 : fd_compact_vote_state_update_switch_new(mem);
1308 0 : fd_compact_vote_state_update_generate( &self->compact_vote_state_update, alloc_mem, rng );
1309 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
1310 0 : return mem;
1311 0 : }
1312 :
1313 0 : void *fd_compact_tower_sync_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1314 0 : fd_compact_tower_sync_t *self = (fd_compact_tower_sync_t *) mem;
1315 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_compact_tower_sync_t);
1316 0 : fd_compact_tower_sync_new(mem);
1317 0 : self->root = fd_rng_ulong( rng );
1318 0 : ulong lockout_offsets_len = fd_rng_ulong( rng ) % 8;
1319 0 : ulong lockout_offsets_max = fd_ulong_max( lockout_offsets_len, 32 );
1320 0 : self->lockout_offsets = deq_fd_lockout_offset_t_join_new( alloc_mem, lockout_offsets_max );
1321 0 : for( ulong i=0; i < lockout_offsets_len; i++ ) {
1322 0 : fd_lockout_offset_t * elem = deq_fd_lockout_offset_t_push_tail_nocopy( self->lockout_offsets );
1323 0 : fd_lockout_offset_generate( elem, alloc_mem, rng );
1324 0 : }
1325 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
1326 0 : {
1327 0 : self->has_timestamp = fd_rng_uchar( rng ) % 2;
1328 0 : if( self->has_timestamp ) {
1329 0 : LLVMFuzzerMutate( (uchar *)&(self->timestamp), sizeof(long), sizeof(long) );
1330 0 : }
1331 0 : }
1332 0 : fd_hash_generate( &self->block_id, alloc_mem, rng );
1333 0 : return mem;
1334 0 : }
1335 :
1336 :
1337 0 : void *fd_tower_sync_switch_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1338 0 : fd_tower_sync_switch_t *self = (fd_tower_sync_switch_t *) mem;
1339 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_tower_sync_switch_t);
1340 0 : fd_tower_sync_switch_new(mem);
1341 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
1342 0 : return mem;
1343 0 : }
1344 :
1345 0 : void *fd_slot_history_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1346 0 : fd_slot_history_t *self = (fd_slot_history_t *) mem;
1347 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_history_t);
1348 0 : fd_slot_history_new(mem);
1349 0 : {
1350 0 : self->has_bits = fd_rng_uchar( rng ) % 2;
1351 0 : if( self->has_bits ) {
1352 0 : self->bits_bitvec_len = fd_rng_ulong( rng ) % 8;
1353 0 : if( self->bits_bitvec_len ) {
1354 0 : self->bits_bitvec = (ulong *) *alloc_mem;
1355 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong)*self->bits_bitvec_len;
1356 0 : LLVMFuzzerMutate( (uchar *) self->bits_bitvec, sizeof(ulong)*self->bits_bitvec_len, sizeof(ulong)*self->bits_bitvec_len );
1357 0 : } else {
1358 0 : self->bits_bitvec = NULL;
1359 0 : }
1360 0 : self->bits_len = self->bits_bitvec_len;
1361 0 : } else {
1362 0 : self->bits_len = 0UL;
1363 0 : }
1364 0 : }
1365 0 : self->next_slot = fd_rng_ulong( rng );
1366 0 : return mem;
1367 0 : }
1368 :
1369 0 : void *fd_slot_hash_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1370 0 : fd_slot_hash_t *self = (fd_slot_hash_t *) mem;
1371 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_hash_t);
1372 0 : fd_slot_hash_new(mem);
1373 0 : self->slot = fd_rng_ulong( rng );
1374 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
1375 0 : return mem;
1376 0 : }
1377 :
1378 0 : void *fd_slot_hashes_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1379 0 : fd_slot_hashes_t *self = (fd_slot_hashes_t *) mem;
1380 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_hashes_t);
1381 0 : fd_slot_hashes_new(mem);
1382 0 : ulong hashes_len = fd_rng_ulong( rng ) % 8;
1383 0 : ulong hashes_max = fd_ulong_max( hashes_len, 512 );
1384 0 : self->hashes = deq_fd_slot_hash_t_join_new( alloc_mem, hashes_max );
1385 0 : for( ulong i=0; i < hashes_len; i++ ) {
1386 0 : fd_slot_hash_t * elem = deq_fd_slot_hash_t_push_tail_nocopy( self->hashes );
1387 0 : fd_slot_hash_generate( elem, alloc_mem, rng );
1388 0 : }
1389 0 : return mem;
1390 0 : }
1391 :
1392 0 : void *fd_block_block_hash_entry_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1393 0 : fd_block_block_hash_entry_t *self = (fd_block_block_hash_entry_t *) mem;
1394 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_block_block_hash_entry_t);
1395 0 : fd_block_block_hash_entry_new(mem);
1396 0 : fd_hash_generate( &self->blockhash, alloc_mem, rng );
1397 0 : fd_fee_calculator_generate( &self->fee_calculator, alloc_mem, rng );
1398 0 : return mem;
1399 0 : }
1400 :
1401 0 : void *fd_recent_block_hashes_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1402 0 : fd_recent_block_hashes_t *self = (fd_recent_block_hashes_t *) mem;
1403 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_recent_block_hashes_t);
1404 0 : fd_recent_block_hashes_new(mem);
1405 0 : ulong hashes_len = fd_rng_ulong( rng ) % 8;
1406 0 : ulong hashes_max = fd_ulong_max( hashes_len, 151 );
1407 0 : self->hashes = deq_fd_block_block_hash_entry_t_join_new( alloc_mem, hashes_max );
1408 0 : for( ulong i=0; i < hashes_len; i++ ) {
1409 0 : fd_block_block_hash_entry_t * elem = deq_fd_block_block_hash_entry_t_push_tail_nocopy( self->hashes );
1410 0 : fd_block_block_hash_entry_generate( elem, alloc_mem, rng );
1411 0 : }
1412 0 : return mem;
1413 0 : }
1414 :
1415 0 : void *fd_slot_meta_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1416 0 : fd_slot_meta_t *self = (fd_slot_meta_t *) mem;
1417 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_meta_t);
1418 0 : fd_slot_meta_new(mem);
1419 0 : self->slot = fd_rng_ulong( rng );
1420 0 : self->consumed = fd_rng_ulong( rng );
1421 0 : self->received = fd_rng_ulong( rng );
1422 0 : self->first_shred_timestamp = fd_rng_long( rng );
1423 0 : self->last_index = fd_rng_ulong( rng );
1424 0 : self->parent_slot = fd_rng_ulong( rng );
1425 0 : self->next_slot_len = fd_rng_ulong( rng ) % 8;
1426 0 : if( self->next_slot_len ) {
1427 0 : self->next_slot = (ulong *) *alloc_mem;
1428 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong)*self->next_slot_len;
1429 0 : LLVMFuzzerMutate( (uchar *) self->next_slot, sizeof(ulong)*self->next_slot_len, sizeof(ulong)*self->next_slot_len );
1430 0 : } else {
1431 0 : self->next_slot = NULL;
1432 0 : }
1433 0 : self->is_connected = fd_rng_uchar( rng );
1434 0 : self->entry_end_indexes_len = fd_rng_ulong( rng ) % 8;
1435 0 : if( self->entry_end_indexes_len ) {
1436 0 : self->entry_end_indexes = (uint *) *alloc_mem;
1437 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(uint)*self->entry_end_indexes_len;
1438 0 : LLVMFuzzerMutate( (uchar *) self->entry_end_indexes, sizeof(uint)*self->entry_end_indexes_len, sizeof(uint)*self->entry_end_indexes_len );
1439 0 : } else {
1440 0 : self->entry_end_indexes = NULL;
1441 0 : }
1442 0 : return mem;
1443 0 : }
1444 :
1445 0 : void *fd_clock_timestamp_vote_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1446 0 : fd_clock_timestamp_vote_t *self = (fd_clock_timestamp_vote_t *) mem;
1447 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_clock_timestamp_vote_t);
1448 0 : fd_clock_timestamp_vote_new(mem);
1449 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
1450 0 : self->timestamp = fd_rng_long( rng );
1451 0 : self->slot = fd_rng_ulong( rng );
1452 0 : return mem;
1453 0 : }
1454 :
1455 0 : void *fd_clock_timestamp_votes_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1456 0 : fd_clock_timestamp_votes_t *self = (fd_clock_timestamp_votes_t *) mem;
1457 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_clock_timestamp_votes_t);
1458 0 : fd_clock_timestamp_votes_new(mem);
1459 0 : ulong votes_len = fd_rng_ulong( rng ) % 8;
1460 0 : self->votes_pool = fd_clock_timestamp_vote_t_map_join_new( alloc_mem, fd_ulong_max( votes_len, 15000 ) );
1461 0 : self->votes_root = NULL;
1462 0 : for( ulong i=0; i < votes_len; i++ ) {
1463 0 : fd_clock_timestamp_vote_t_mapnode_t * node = fd_clock_timestamp_vote_t_map_acquire( self->votes_pool );
1464 0 : fd_clock_timestamp_vote_generate( &node->elem, alloc_mem, rng );
1465 0 : fd_clock_timestamp_vote_t_map_insert( self->votes_pool, &self->votes_root, node );
1466 0 : }
1467 0 : return mem;
1468 0 : }
1469 :
1470 0 : void *fd_sysvar_fees_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1471 0 : fd_sysvar_fees_t *self = (fd_sysvar_fees_t *) mem;
1472 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_sysvar_fees_t);
1473 0 : fd_sysvar_fees_new(mem);
1474 0 : fd_fee_calculator_generate( &self->fee_calculator, alloc_mem, rng );
1475 0 : return mem;
1476 0 : }
1477 :
1478 0 : void *fd_sysvar_epoch_rewards_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1479 0 : fd_sysvar_epoch_rewards_t *self = (fd_sysvar_epoch_rewards_t *) mem;
1480 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_sysvar_epoch_rewards_t);
1481 0 : fd_sysvar_epoch_rewards_new(mem);
1482 0 : self->distribution_starting_block_height = fd_rng_ulong( rng );
1483 0 : self->num_partitions = fd_rng_ulong( rng );
1484 0 : fd_hash_generate( &self->parent_blockhash, alloc_mem, rng );
1485 0 : self->total_points = fd_rng_uint128( rng );
1486 0 : self->total_rewards = fd_rng_ulong( rng );
1487 0 : self->distributed_rewards = fd_rng_ulong( rng );
1488 0 : self->active = fd_rng_uchar( rng );
1489 0 : return mem;
1490 0 : }
1491 :
1492 0 : void *fd_config_keys_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1493 0 : fd_config_keys_pair_t *self = (fd_config_keys_pair_t *) mem;
1494 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_config_keys_pair_t);
1495 0 : fd_config_keys_pair_new(mem);
1496 0 : fd_pubkey_generate( &self->key, alloc_mem, rng );
1497 0 : self->signer = fd_rng_uchar( rng );
1498 0 : return mem;
1499 0 : }
1500 :
1501 0 : void *fd_stake_config_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1502 0 : fd_stake_config_t *self = (fd_stake_config_t *) mem;
1503 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_config_t);
1504 0 : fd_stake_config_new(mem);
1505 0 : self->config_keys_len = fd_rng_ulong( rng ) % 8;
1506 0 : if( self->config_keys_len ) {
1507 0 : self->config_keys = (fd_config_keys_pair_t *) *alloc_mem;
1508 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_config_keys_pair_t)*self->config_keys_len;
1509 0 : for( ulong i=0; i < self->config_keys_len; i++ ) {
1510 0 : fd_config_keys_pair_new( self->config_keys + i );
1511 0 : fd_config_keys_pair_generate( self->config_keys + i, alloc_mem, rng );
1512 0 : }
1513 0 : } else {
1514 0 : self->config_keys = NULL;
1515 0 : }
1516 0 : self->warmup_cooldown_rate = fd_rng_double_o( rng );
1517 0 : self->slash_penalty = fd_rng_uchar( rng );
1518 0 : return mem;
1519 0 : }
1520 :
1521 0 : void *fd_feature_entry_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1522 0 : fd_feature_entry_t *self = (fd_feature_entry_t *) mem;
1523 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_feature_entry_t);
1524 0 : fd_feature_entry_new(mem);
1525 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
1526 0 : self->description_len = fd_rng_ulong( rng ) % 8;
1527 0 : if( self->description_len ) {
1528 0 : self->description = (uchar *) *alloc_mem;
1529 0 : *alloc_mem = (uchar *) *alloc_mem + self->description_len;
1530 0 : for( ulong i=0; i < self->description_len; ++i) { self->description[i] = fd_rng_uchar( rng ) % 0x80; }
1531 0 : } else {
1532 0 : self->description = NULL;
1533 0 : }
1534 0 : self->since_slot = fd_rng_ulong( rng );
1535 0 : return mem;
1536 0 : }
1537 :
1538 0 : void *fd_cluster_type_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1539 0 : fd_cluster_type_t *self = (fd_cluster_type_t *) mem;
1540 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_cluster_type_t);
1541 0 : fd_cluster_type_new(mem);
1542 0 : self->discriminant = fd_rng_uint( rng ) % 4;
1543 0 : return mem;
1544 0 : }
1545 :
1546 0 : void *fd_cluster_version_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1547 0 : fd_cluster_version_t *self = (fd_cluster_version_t *) mem;
1548 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_cluster_version_t);
1549 0 : fd_cluster_version_new(mem);
1550 0 : self->major = fd_rng_uint( rng );
1551 0 : self->minor = fd_rng_uint( rng );
1552 0 : self->patch = fd_rng_uint( rng );
1553 0 : return mem;
1554 0 : }
1555 :
1556 0 : void *fd_stake_reward_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1557 0 : fd_stake_reward_t *self = (fd_stake_reward_t *) mem;
1558 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_reward_t);
1559 0 : fd_stake_reward_new(mem);
1560 0 : self->prev = fd_rng_ulong( rng );
1561 0 : self->next = fd_rng_ulong( rng );
1562 0 : self->parent = fd_rng_ulong( rng );
1563 0 : fd_pubkey_generate( &self->stake_pubkey, alloc_mem, rng );
1564 0 : self->credits_observed = fd_rng_ulong( rng );
1565 0 : self->lamports = fd_rng_ulong( rng );
1566 0 : self->valid = fd_rng_uchar( rng );
1567 0 : return mem;
1568 0 : }
1569 :
1570 0 : void *fd_vote_reward_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1571 0 : fd_vote_reward_t *self = (fd_vote_reward_t *) mem;
1572 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_reward_t);
1573 0 : fd_vote_reward_new(mem);
1574 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
1575 0 : self->vote_rewards = fd_rng_ulong( rng );
1576 0 : self->commission = fd_rng_uchar( rng );
1577 0 : self->needs_store = fd_rng_uchar( rng );
1578 0 : return mem;
1579 0 : }
1580 :
1581 0 : void *fd_point_value_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1582 0 : fd_point_value_t *self = (fd_point_value_t *) mem;
1583 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_point_value_t);
1584 0 : fd_point_value_new(mem);
1585 0 : self->rewards = fd_rng_ulong( rng );
1586 0 : self->points = fd_rng_uint128( rng );
1587 0 : return mem;
1588 0 : }
1589 :
1590 0 : void *fd_partitioned_stake_rewards_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1591 0 : fd_partitioned_stake_rewards_t *self = (fd_partitioned_stake_rewards_t *) mem;
1592 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_partitioned_stake_rewards_t);
1593 0 : fd_partitioned_stake_rewards_new(mem);
1594 0 : self->partitions_len = fd_rng_ulong( rng ) % 8;
1595 0 : ulong total_count = 0UL;
1596 0 : for( ulong i=0; i < 4096; i++ ) {
1597 0 : self->partitions_lengths[i] = fd_rng_ulong( rng ) % 8;
1598 0 : total_count += self->partitions_lengths[ i ];
1599 0 : }
1600 0 : self->pool = fd_partitioned_stake_rewards_pool_join_new( alloc_mem, total_count );
1601 0 : self->partitions = fd_partitioned_stake_rewards_dlist_join_new( alloc_mem, self->partitions_len );
1602 0 : for( ulong i=0; i < self->partitions_len; i++ ) {
1603 0 : fd_partitioned_stake_rewards_dlist_new( &self->partitions[ i ] );
1604 0 : for( ulong j=0; j < self->partitions_lengths[ i ]; j++ ) {
1605 0 : fd_stake_reward_t * ele = fd_partitioned_stake_rewards_pool_ele_acquire( self->pool );
1606 0 : fd_stake_reward_new( ele );
1607 0 : fd_stake_reward_generate( ele, alloc_mem, rng );
1608 0 : fd_partitioned_stake_rewards_dlist_ele_push_tail( &self->partitions[ i ], ele, self->pool );
1609 0 : }
1610 0 : }
1611 0 : return mem;
1612 0 : }
1613 :
1614 0 : void *fd_stake_reward_calculation_partitioned_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1615 0 : fd_stake_reward_calculation_partitioned_t *self = (fd_stake_reward_calculation_partitioned_t *) mem;
1616 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_reward_calculation_partitioned_t);
1617 0 : fd_stake_reward_calculation_partitioned_new(mem);
1618 0 : fd_partitioned_stake_rewards_generate( &self->partitioned_stake_rewards, alloc_mem, rng );
1619 0 : self->total_stake_rewards_lamports = fd_rng_ulong( rng );
1620 0 : return mem;
1621 0 : }
1622 :
1623 0 : void *fd_stake_reward_calculation_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1624 0 : fd_stake_reward_calculation_t *self = (fd_stake_reward_calculation_t *) mem;
1625 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_reward_calculation_t);
1626 0 : fd_stake_reward_calculation_new(mem);
1627 0 : self->stake_rewards_len = fd_rng_ulong( rng ) % 8;
1628 0 : self->pool = fd_stake_reward_calculation_pool_join_new( alloc_mem, self->stake_rewards_len );
1629 0 : self->stake_rewards = fd_stake_reward_calculation_dlist_join_new( alloc_mem, self->stake_rewards_len );
1630 0 : fd_stake_reward_calculation_dlist_new( self->stake_rewards );
1631 0 : for( ulong i=0; i < self->stake_rewards_len; i++ ) {
1632 0 : fd_stake_reward_t * ele = fd_stake_reward_calculation_pool_ele_acquire( self->pool );
1633 0 : fd_stake_reward_new( ele );
1634 0 : fd_stake_reward_generate( ele, alloc_mem, rng );
1635 0 : fd_stake_reward_calculation_dlist_ele_push_tail( self->stake_rewards, ele, self->pool );
1636 0 : }
1637 0 : self->total_stake_rewards_lamports = fd_rng_ulong( rng );
1638 0 : return mem;
1639 0 : }
1640 :
1641 0 : void *fd_calculate_stake_vote_rewards_result_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1642 0 : fd_calculate_stake_vote_rewards_result_t *self = (fd_calculate_stake_vote_rewards_result_t *) mem;
1643 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_calculate_stake_vote_rewards_result_t);
1644 0 : fd_calculate_stake_vote_rewards_result_new(mem);
1645 0 : fd_stake_reward_calculation_generate( &self->stake_reward_calculation, alloc_mem, rng );
1646 0 : ulong vote_reward_map_len = fd_rng_ulong( rng ) % 8;
1647 0 : self->vote_reward_map_pool = fd_vote_reward_t_map_join_new( alloc_mem, fd_ulong_max( vote_reward_map_len, 15000 ) );
1648 0 : self->vote_reward_map_root = NULL;
1649 0 : for( ulong i=0; i < vote_reward_map_len; i++ ) {
1650 0 : fd_vote_reward_t_mapnode_t * node = fd_vote_reward_t_map_acquire( self->vote_reward_map_pool );
1651 0 : fd_vote_reward_generate( &node->elem, alloc_mem, rng );
1652 0 : fd_vote_reward_t_map_insert( self->vote_reward_map_pool, &self->vote_reward_map_root, node );
1653 0 : }
1654 0 : return mem;
1655 0 : }
1656 :
1657 0 : void *fd_calculate_validator_rewards_result_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1658 0 : fd_calculate_validator_rewards_result_t *self = (fd_calculate_validator_rewards_result_t *) mem;
1659 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_calculate_validator_rewards_result_t);
1660 0 : fd_calculate_validator_rewards_result_new(mem);
1661 0 : fd_calculate_stake_vote_rewards_result_generate( &self->calculate_stake_vote_rewards_result, alloc_mem, rng );
1662 0 : fd_point_value_generate( &self->point_value, alloc_mem, rng );
1663 0 : return mem;
1664 0 : }
1665 :
1666 0 : void *fd_partitioned_rewards_calculation_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1667 0 : fd_partitioned_rewards_calculation_t *self = (fd_partitioned_rewards_calculation_t *) mem;
1668 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_partitioned_rewards_calculation_t);
1669 0 : fd_partitioned_rewards_calculation_new(mem);
1670 0 : ulong vote_reward_map_len = fd_rng_ulong( rng ) % 8;
1671 0 : self->vote_reward_map_pool = fd_vote_reward_t_map_join_new( alloc_mem, fd_ulong_max( vote_reward_map_len, 15000 ) );
1672 0 : self->vote_reward_map_root = NULL;
1673 0 : for( ulong i=0; i < vote_reward_map_len; i++ ) {
1674 0 : fd_vote_reward_t_mapnode_t * node = fd_vote_reward_t_map_acquire( self->vote_reward_map_pool );
1675 0 : fd_vote_reward_generate( &node->elem, alloc_mem, rng );
1676 0 : fd_vote_reward_t_map_insert( self->vote_reward_map_pool, &self->vote_reward_map_root, node );
1677 0 : }
1678 0 : fd_stake_reward_calculation_partitioned_generate( &self->stake_rewards_by_partition, alloc_mem, rng );
1679 0 : self->old_vote_balance_and_staked = fd_rng_ulong( rng );
1680 0 : self->validator_rewards = fd_rng_ulong( rng );
1681 0 : self->validator_rate = fd_rng_double_o( rng );
1682 0 : self->foundation_rate = fd_rng_double_o( rng );
1683 0 : self->prev_epoch_duration_in_years = fd_rng_double_o( rng );
1684 0 : self->capitalization = fd_rng_ulong( rng );
1685 0 : fd_point_value_generate( &self->point_value, alloc_mem, rng );
1686 0 : return mem;
1687 0 : }
1688 :
1689 0 : void *fd_start_block_height_and_rewards_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1690 0 : fd_start_block_height_and_rewards_t *self = (fd_start_block_height_and_rewards_t *) mem;
1691 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_start_block_height_and_rewards_t);
1692 0 : fd_start_block_height_and_rewards_new(mem);
1693 0 : self->distribution_starting_block_height = fd_rng_ulong( rng );
1694 0 : fd_partitioned_stake_rewards_generate( &self->partitioned_stake_rewards, alloc_mem, rng );
1695 0 : return mem;
1696 0 : }
1697 :
1698 0 : void *fd_fd_epoch_reward_status_inner_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1699 0 : fd_fd_epoch_reward_status_inner_t *self = (fd_fd_epoch_reward_status_inner_t *) mem;
1700 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_fd_epoch_reward_status_inner_t);
1701 0 : fd_fd_epoch_reward_status_inner_new(mem);
1702 0 : fd_start_block_height_and_rewards_generate( &self->Active, alloc_mem, rng );
1703 0 : return mem;
1704 0 : }
1705 :
1706 0 : void fd_epoch_reward_status_inner_generate( fd_epoch_reward_status_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
1707 0 : switch (discriminant) {
1708 0 : case 0: {
1709 0 : fd_start_block_height_and_rewards_generate( &self->Active, alloc_mem, rng );
1710 0 : break;
1711 0 : }
1712 0 : }
1713 0 : }
1714 0 : void *fd_epoch_reward_status_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1715 0 : fd_epoch_reward_status_t *self = (fd_epoch_reward_status_t *) mem;
1716 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_epoch_reward_status_t);
1717 0 : fd_epoch_reward_status_new(mem);
1718 0 : self->discriminant = fd_rng_uint( rng ) % 2;
1719 0 : fd_epoch_reward_status_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1720 0 : return mem;
1721 0 : }
1722 :
1723 0 : void *fd_prev_epoch_inflation_rewards_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1724 0 : fd_prev_epoch_inflation_rewards_t *self = (fd_prev_epoch_inflation_rewards_t *) mem;
1725 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_prev_epoch_inflation_rewards_t);
1726 0 : fd_prev_epoch_inflation_rewards_new(mem);
1727 0 : self->validator_rewards = fd_rng_ulong( rng );
1728 0 : self->prev_epoch_duration_in_years = fd_rng_double_o( rng );
1729 0 : self->validator_rate = fd_rng_double_o( rng );
1730 0 : self->foundation_rate = fd_rng_double_o( rng );
1731 0 : return mem;
1732 0 : }
1733 :
1734 0 : void *fd_vote_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1735 0 : fd_vote_t *self = (fd_vote_t *) mem;
1736 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_t);
1737 0 : fd_vote_new(mem);
1738 0 : ulong slots_len = fd_rng_ulong( rng ) % 8;
1739 0 : self->slots = deq_ulong_join_new( alloc_mem, slots_len );
1740 0 : for( ulong i=0; i < slots_len; i++ ) {
1741 0 : ulong * elem = deq_ulong_push_tail_nocopy( self->slots );
1742 0 : LLVMFuzzerMutate( (uchar *) elem, sizeof(ulong), sizeof(ulong) );
1743 0 : }
1744 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
1745 0 : {
1746 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
1747 0 : if( !is_null ) {
1748 0 : self->timestamp = (long *) *alloc_mem;
1749 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(long);
1750 0 : LLVMFuzzerMutate( (uchar *)self->timestamp, sizeof(long), sizeof(long) );
1751 0 : }
1752 0 : else {
1753 0 : self->timestamp = NULL;
1754 0 : }
1755 0 : }
1756 0 : return mem;
1757 0 : }
1758 :
1759 0 : void *fd_vote_init_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1760 0 : fd_vote_init_t *self = (fd_vote_init_t *) mem;
1761 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_init_t);
1762 0 : fd_vote_init_new(mem);
1763 0 : fd_pubkey_generate( &self->node_pubkey, alloc_mem, rng );
1764 0 : fd_pubkey_generate( &self->authorized_voter, alloc_mem, rng );
1765 0 : fd_pubkey_generate( &self->authorized_withdrawer, alloc_mem, rng );
1766 0 : self->commission = fd_rng_uchar( rng );
1767 0 : return mem;
1768 0 : }
1769 :
1770 0 : void *fd_vote_authorize_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1771 0 : fd_vote_authorize_t *self = (fd_vote_authorize_t *) mem;
1772 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_authorize_t);
1773 0 : fd_vote_authorize_new(mem);
1774 0 : self->discriminant = fd_rng_uint( rng ) % 2;
1775 0 : return mem;
1776 0 : }
1777 :
1778 0 : void *fd_vote_authorize_pubkey_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1779 0 : fd_vote_authorize_pubkey_t *self = (fd_vote_authorize_pubkey_t *) mem;
1780 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_authorize_pubkey_t);
1781 0 : fd_vote_authorize_pubkey_new(mem);
1782 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
1783 0 : fd_vote_authorize_generate( &self->vote_authorize, alloc_mem, rng );
1784 0 : return mem;
1785 0 : }
1786 :
1787 0 : void *fd_vote_switch_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1788 0 : fd_vote_switch_t *self = (fd_vote_switch_t *) mem;
1789 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_switch_t);
1790 0 : fd_vote_switch_new(mem);
1791 0 : fd_vote_generate( &self->vote, alloc_mem, rng );
1792 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
1793 0 : return mem;
1794 0 : }
1795 :
1796 0 : void *fd_update_vote_state_switch_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1797 0 : fd_update_vote_state_switch_t *self = (fd_update_vote_state_switch_t *) mem;
1798 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_update_vote_state_switch_t);
1799 0 : fd_update_vote_state_switch_new(mem);
1800 0 : fd_vote_state_update_generate( &self->vote_state_update, alloc_mem, rng );
1801 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
1802 0 : return mem;
1803 0 : }
1804 :
1805 0 : void *fd_vote_authorize_with_seed_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1806 0 : fd_vote_authorize_with_seed_args_t *self = (fd_vote_authorize_with_seed_args_t *) mem;
1807 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_authorize_with_seed_args_t);
1808 0 : fd_vote_authorize_with_seed_args_new(mem);
1809 0 : fd_vote_authorize_generate( &self->authorization_type, alloc_mem, rng );
1810 0 : fd_pubkey_generate( &self->current_authority_derived_key_owner, alloc_mem, rng );
1811 0 : self->current_authority_derived_key_seed_len = fd_rng_ulong( rng ) % 8;
1812 0 : if( self->current_authority_derived_key_seed_len ) {
1813 0 : self->current_authority_derived_key_seed = (uchar *) *alloc_mem;
1814 0 : *alloc_mem = (uchar *) *alloc_mem + self->current_authority_derived_key_seed_len;
1815 0 : for( ulong i=0; i < self->current_authority_derived_key_seed_len; ++i) { self->current_authority_derived_key_seed[i] = fd_rng_uchar( rng ) % 0x80; }
1816 0 : } else {
1817 0 : self->current_authority_derived_key_seed = NULL;
1818 0 : }
1819 0 : fd_pubkey_generate( &self->new_authority, alloc_mem, rng );
1820 0 : return mem;
1821 0 : }
1822 :
1823 0 : void *fd_vote_authorize_checked_with_seed_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1824 0 : fd_vote_authorize_checked_with_seed_args_t *self = (fd_vote_authorize_checked_with_seed_args_t *) mem;
1825 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_authorize_checked_with_seed_args_t);
1826 0 : fd_vote_authorize_checked_with_seed_args_new(mem);
1827 0 : fd_vote_authorize_generate( &self->authorization_type, alloc_mem, rng );
1828 0 : fd_pubkey_generate( &self->current_authority_derived_key_owner, alloc_mem, rng );
1829 0 : self->current_authority_derived_key_seed_len = fd_rng_ulong( rng ) % 8;
1830 0 : if( self->current_authority_derived_key_seed_len ) {
1831 0 : self->current_authority_derived_key_seed = (uchar *) *alloc_mem;
1832 0 : *alloc_mem = (uchar *) *alloc_mem + self->current_authority_derived_key_seed_len;
1833 0 : for( ulong i=0; i < self->current_authority_derived_key_seed_len; ++i) { self->current_authority_derived_key_seed[i] = fd_rng_uchar( rng ) % 0x80; }
1834 0 : } else {
1835 0 : self->current_authority_derived_key_seed = NULL;
1836 0 : }
1837 0 : return mem;
1838 0 : }
1839 :
1840 0 : void fd_vote_instruction_inner_generate( fd_vote_instruction_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
1841 0 : switch (discriminant) {
1842 0 : case 0: {
1843 0 : fd_vote_init_generate( &self->initialize_account, alloc_mem, rng );
1844 0 : break;
1845 0 : }
1846 0 : case 1: {
1847 0 : fd_vote_authorize_pubkey_generate( &self->authorize, alloc_mem, rng );
1848 0 : break;
1849 0 : }
1850 0 : case 2: {
1851 0 : fd_vote_generate( &self->vote, alloc_mem, rng );
1852 0 : break;
1853 0 : }
1854 0 : case 3: {
1855 0 : self->withdraw = fd_rng_ulong( rng );
1856 0 : break;
1857 0 : }
1858 0 : case 5: {
1859 0 : self->update_commission = fd_rng_uchar( rng );
1860 0 : break;
1861 0 : }
1862 0 : case 6: {
1863 0 : fd_vote_switch_generate( &self->vote_switch, alloc_mem, rng );
1864 0 : break;
1865 0 : }
1866 0 : case 7: {
1867 0 : fd_vote_authorize_generate( &self->authorize_checked, alloc_mem, rng );
1868 0 : break;
1869 0 : }
1870 0 : case 8: {
1871 0 : fd_vote_state_update_generate( &self->update_vote_state, alloc_mem, rng );
1872 0 : break;
1873 0 : }
1874 0 : case 9: {
1875 0 : fd_update_vote_state_switch_generate( &self->update_vote_state_switch, alloc_mem, rng );
1876 0 : break;
1877 0 : }
1878 0 : case 10: {
1879 0 : fd_vote_authorize_with_seed_args_generate( &self->authorize_with_seed, alloc_mem, rng );
1880 0 : break;
1881 0 : }
1882 0 : case 11: {
1883 0 : fd_vote_authorize_checked_with_seed_args_generate( &self->authorize_checked_with_seed, alloc_mem, rng );
1884 0 : break;
1885 0 : }
1886 0 : case 12: {
1887 0 : fd_compact_vote_state_update_generate( &self->compact_update_vote_state, alloc_mem, rng );
1888 0 : break;
1889 0 : }
1890 0 : case 13: {
1891 0 : fd_compact_vote_state_update_switch_generate( &self->compact_update_vote_state_switch, alloc_mem, rng );
1892 0 : break;
1893 0 : }
1894 0 : case 14: {
1895 0 : break;
1896 0 : }
1897 0 : case 15: {
1898 0 : fd_tower_sync_switch_generate( &self->tower_sync_switch, alloc_mem, rng );
1899 0 : break;
1900 0 : }
1901 0 : }
1902 0 : }
1903 0 : void *fd_vote_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1904 0 : fd_vote_instruction_t *self = (fd_vote_instruction_t *) mem;
1905 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_instruction_t);
1906 0 : fd_vote_instruction_new(mem);
1907 0 : self->discriminant = fd_rng_uint( rng ) % 16;
1908 0 : while( self->discriminant == 14 || self->discriminant == 15 ) { self->discriminant = fd_rng_uint( rng ) % 16; }
1909 0 : fd_vote_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1910 0 : return mem;
1911 0 : }
1912 :
1913 0 : void *fd_system_program_instruction_create_account_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1914 0 : fd_system_program_instruction_create_account_t *self = (fd_system_program_instruction_create_account_t *) mem;
1915 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_program_instruction_create_account_t);
1916 0 : fd_system_program_instruction_create_account_new(mem);
1917 0 : self->lamports = fd_rng_ulong( rng );
1918 0 : self->space = fd_rng_ulong( rng );
1919 0 : fd_pubkey_generate( &self->owner, alloc_mem, rng );
1920 0 : return mem;
1921 0 : }
1922 :
1923 0 : void *fd_system_program_instruction_create_account_with_seed_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1924 0 : fd_system_program_instruction_create_account_with_seed_t *self = (fd_system_program_instruction_create_account_with_seed_t *) mem;
1925 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_program_instruction_create_account_with_seed_t);
1926 0 : fd_system_program_instruction_create_account_with_seed_new(mem);
1927 0 : fd_pubkey_generate( &self->base, alloc_mem, rng );
1928 0 : self->seed_len = fd_rng_ulong( rng ) % 8;
1929 0 : if( self->seed_len ) {
1930 0 : self->seed = (uchar *) *alloc_mem;
1931 0 : *alloc_mem = (uchar *) *alloc_mem + self->seed_len;
1932 0 : for( ulong i=0; i < self->seed_len; ++i) { self->seed[i] = fd_rng_uchar( rng ) % 0x80; }
1933 0 : } else {
1934 0 : self->seed = NULL;
1935 0 : }
1936 0 : self->lamports = fd_rng_ulong( rng );
1937 0 : self->space = fd_rng_ulong( rng );
1938 0 : fd_pubkey_generate( &self->owner, alloc_mem, rng );
1939 0 : return mem;
1940 0 : }
1941 :
1942 0 : void *fd_system_program_instruction_allocate_with_seed_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1943 0 : fd_system_program_instruction_allocate_with_seed_t *self = (fd_system_program_instruction_allocate_with_seed_t *) mem;
1944 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_program_instruction_allocate_with_seed_t);
1945 0 : fd_system_program_instruction_allocate_with_seed_new(mem);
1946 0 : fd_pubkey_generate( &self->base, alloc_mem, rng );
1947 0 : self->seed_len = fd_rng_ulong( rng ) % 8;
1948 0 : if( self->seed_len ) {
1949 0 : self->seed = (uchar *) *alloc_mem;
1950 0 : *alloc_mem = (uchar *) *alloc_mem + self->seed_len;
1951 0 : for( ulong i=0; i < self->seed_len; ++i) { self->seed[i] = fd_rng_uchar( rng ) % 0x80; }
1952 0 : } else {
1953 0 : self->seed = NULL;
1954 0 : }
1955 0 : self->space = fd_rng_ulong( rng );
1956 0 : fd_pubkey_generate( &self->owner, alloc_mem, rng );
1957 0 : return mem;
1958 0 : }
1959 :
1960 0 : void *fd_system_program_instruction_assign_with_seed_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1961 0 : fd_system_program_instruction_assign_with_seed_t *self = (fd_system_program_instruction_assign_with_seed_t *) mem;
1962 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_program_instruction_assign_with_seed_t);
1963 0 : fd_system_program_instruction_assign_with_seed_new(mem);
1964 0 : fd_pubkey_generate( &self->base, alloc_mem, rng );
1965 0 : self->seed_len = fd_rng_ulong( rng ) % 8;
1966 0 : if( self->seed_len ) {
1967 0 : self->seed = (uchar *) *alloc_mem;
1968 0 : *alloc_mem = (uchar *) *alloc_mem + self->seed_len;
1969 0 : for( ulong i=0; i < self->seed_len; ++i) { self->seed[i] = fd_rng_uchar( rng ) % 0x80; }
1970 0 : } else {
1971 0 : self->seed = NULL;
1972 0 : }
1973 0 : fd_pubkey_generate( &self->owner, alloc_mem, rng );
1974 0 : return mem;
1975 0 : }
1976 :
1977 0 : void *fd_system_program_instruction_transfer_with_seed_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1978 0 : fd_system_program_instruction_transfer_with_seed_t *self = (fd_system_program_instruction_transfer_with_seed_t *) mem;
1979 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_program_instruction_transfer_with_seed_t);
1980 0 : fd_system_program_instruction_transfer_with_seed_new(mem);
1981 0 : self->lamports = fd_rng_ulong( rng );
1982 0 : self->from_seed_len = fd_rng_ulong( rng ) % 8;
1983 0 : if( self->from_seed_len ) {
1984 0 : self->from_seed = (uchar *) *alloc_mem;
1985 0 : *alloc_mem = (uchar *) *alloc_mem + self->from_seed_len;
1986 0 : for( ulong i=0; i < self->from_seed_len; ++i) { self->from_seed[i] = fd_rng_uchar( rng ) % 0x80; }
1987 0 : } else {
1988 0 : self->from_seed = NULL;
1989 0 : }
1990 0 : fd_pubkey_generate( &self->from_owner, alloc_mem, rng );
1991 0 : return mem;
1992 0 : }
1993 :
1994 0 : void fd_system_program_instruction_inner_generate( fd_system_program_instruction_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
1995 0 : switch (discriminant) {
1996 0 : case 0: {
1997 0 : fd_system_program_instruction_create_account_generate( &self->create_account, alloc_mem, rng );
1998 0 : break;
1999 0 : }
2000 0 : case 1: {
2001 0 : fd_pubkey_generate( &self->assign, alloc_mem, rng );
2002 0 : break;
2003 0 : }
2004 0 : case 2: {
2005 0 : self->transfer = fd_rng_ulong( rng );
2006 0 : break;
2007 0 : }
2008 0 : case 3: {
2009 0 : fd_system_program_instruction_create_account_with_seed_generate( &self->create_account_with_seed, alloc_mem, rng );
2010 0 : break;
2011 0 : }
2012 0 : case 5: {
2013 0 : self->withdraw_nonce_account = fd_rng_ulong( rng );
2014 0 : break;
2015 0 : }
2016 0 : case 6: {
2017 0 : fd_pubkey_generate( &self->initialize_nonce_account, alloc_mem, rng );
2018 0 : break;
2019 0 : }
2020 0 : case 7: {
2021 0 : fd_pubkey_generate( &self->authorize_nonce_account, alloc_mem, rng );
2022 0 : break;
2023 0 : }
2024 0 : case 8: {
2025 0 : self->allocate = fd_rng_ulong( rng );
2026 0 : break;
2027 0 : }
2028 0 : case 9: {
2029 0 : fd_system_program_instruction_allocate_with_seed_generate( &self->allocate_with_seed, alloc_mem, rng );
2030 0 : break;
2031 0 : }
2032 0 : case 10: {
2033 0 : fd_system_program_instruction_assign_with_seed_generate( &self->assign_with_seed, alloc_mem, rng );
2034 0 : break;
2035 0 : }
2036 0 : case 11: {
2037 0 : fd_system_program_instruction_transfer_with_seed_generate( &self->transfer_with_seed, alloc_mem, rng );
2038 0 : break;
2039 0 : }
2040 0 : }
2041 0 : }
2042 0 : void *fd_system_program_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2043 0 : fd_system_program_instruction_t *self = (fd_system_program_instruction_t *) mem;
2044 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_program_instruction_t);
2045 0 : fd_system_program_instruction_new(mem);
2046 0 : self->discriminant = fd_rng_uint( rng ) % 13;
2047 0 : fd_system_program_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2048 0 : return mem;
2049 0 : }
2050 :
2051 0 : void *fd_system_error_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2052 0 : fd_system_error_t *self = (fd_system_error_t *) mem;
2053 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_error_t);
2054 0 : fd_system_error_new(mem);
2055 0 : self->discriminant = fd_rng_uint( rng ) % 9;
2056 0 : return mem;
2057 0 : }
2058 :
2059 0 : void *fd_stake_authorized_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2060 0 : fd_stake_authorized_t *self = (fd_stake_authorized_t *) mem;
2061 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_authorized_t);
2062 0 : fd_stake_authorized_new(mem);
2063 0 : fd_pubkey_generate( &self->staker, alloc_mem, rng );
2064 0 : fd_pubkey_generate( &self->withdrawer, alloc_mem, rng );
2065 0 : return mem;
2066 0 : }
2067 :
2068 0 : void *fd_stake_lockup_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2069 0 : fd_stake_lockup_t *self = (fd_stake_lockup_t *) mem;
2070 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_lockup_t);
2071 0 : fd_stake_lockup_new(mem);
2072 0 : self->unix_timestamp = fd_rng_long( rng );
2073 0 : self->epoch = fd_rng_ulong( rng );
2074 0 : fd_pubkey_generate( &self->custodian, alloc_mem, rng );
2075 0 : return mem;
2076 0 : }
2077 :
2078 0 : void *fd_stake_instruction_initialize_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2079 0 : fd_stake_instruction_initialize_t *self = (fd_stake_instruction_initialize_t *) mem;
2080 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_instruction_initialize_t);
2081 0 : fd_stake_instruction_initialize_new(mem);
2082 0 : fd_stake_authorized_generate( &self->authorized, alloc_mem, rng );
2083 0 : fd_stake_lockup_generate( &self->lockup, alloc_mem, rng );
2084 0 : return mem;
2085 0 : }
2086 :
2087 0 : void *fd_stake_lockup_custodian_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2088 0 : fd_stake_lockup_custodian_args_t *self = (fd_stake_lockup_custodian_args_t *) mem;
2089 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_lockup_custodian_args_t);
2090 0 : fd_stake_lockup_custodian_args_new(mem);
2091 0 : fd_stake_lockup_generate( &self->lockup, alloc_mem, rng );
2092 0 : fd_sol_sysvar_clock_generate( &self->clock, alloc_mem, rng );
2093 0 : {
2094 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
2095 0 : if( !is_null ) {
2096 0 : self->custodian = (fd_pubkey_t *) *alloc_mem;
2097 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t);
2098 0 : fd_pubkey_new( self->custodian );
2099 0 : fd_pubkey_generate( self->custodian, alloc_mem, rng );
2100 0 : }
2101 0 : else {
2102 0 : self->custodian = NULL;
2103 0 : }
2104 0 : }
2105 0 : return mem;
2106 0 : }
2107 :
2108 0 : void *fd_stake_authorize_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2109 0 : fd_stake_authorize_t *self = (fd_stake_authorize_t *) mem;
2110 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_authorize_t);
2111 0 : fd_stake_authorize_new(mem);
2112 0 : self->discriminant = fd_rng_uint( rng ) % 2;
2113 0 : return mem;
2114 0 : }
2115 :
2116 0 : void *fd_stake_instruction_authorize_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2117 0 : fd_stake_instruction_authorize_t *self = (fd_stake_instruction_authorize_t *) mem;
2118 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_instruction_authorize_t);
2119 0 : fd_stake_instruction_authorize_new(mem);
2120 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
2121 0 : fd_stake_authorize_generate( &self->stake_authorize, alloc_mem, rng );
2122 0 : return mem;
2123 0 : }
2124 :
2125 0 : void *fd_authorize_with_seed_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2126 0 : fd_authorize_with_seed_args_t *self = (fd_authorize_with_seed_args_t *) mem;
2127 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_authorize_with_seed_args_t);
2128 0 : fd_authorize_with_seed_args_new(mem);
2129 0 : fd_pubkey_generate( &self->new_authorized_pubkey, alloc_mem, rng );
2130 0 : fd_stake_authorize_generate( &self->stake_authorize, alloc_mem, rng );
2131 0 : self->authority_seed_len = fd_rng_ulong( rng ) % 8;
2132 0 : if( self->authority_seed_len ) {
2133 0 : self->authority_seed = (uchar *) *alloc_mem;
2134 0 : *alloc_mem = (uchar *) *alloc_mem + self->authority_seed_len;
2135 0 : for( ulong i=0; i < self->authority_seed_len; ++i) { self->authority_seed[i] = fd_rng_uchar( rng ) % 0x80; }
2136 0 : } else {
2137 0 : self->authority_seed = NULL;
2138 0 : }
2139 0 : fd_pubkey_generate( &self->authority_owner, alloc_mem, rng );
2140 0 : return mem;
2141 0 : }
2142 :
2143 0 : void *fd_authorize_checked_with_seed_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2144 0 : fd_authorize_checked_with_seed_args_t *self = (fd_authorize_checked_with_seed_args_t *) mem;
2145 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_authorize_checked_with_seed_args_t);
2146 0 : fd_authorize_checked_with_seed_args_new(mem);
2147 0 : fd_stake_authorize_generate( &self->stake_authorize, alloc_mem, rng );
2148 0 : self->authority_seed_len = fd_rng_ulong( rng ) % 8;
2149 0 : if( self->authority_seed_len ) {
2150 0 : self->authority_seed = (uchar *) *alloc_mem;
2151 0 : *alloc_mem = (uchar *) *alloc_mem + self->authority_seed_len;
2152 0 : for( ulong i=0; i < self->authority_seed_len; ++i) { self->authority_seed[i] = fd_rng_uchar( rng ) % 0x80; }
2153 0 : } else {
2154 0 : self->authority_seed = NULL;
2155 0 : }
2156 0 : fd_pubkey_generate( &self->authority_owner, alloc_mem, rng );
2157 0 : return mem;
2158 0 : }
2159 :
2160 0 : void *fd_lockup_checked_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2161 0 : fd_lockup_checked_args_t *self = (fd_lockup_checked_args_t *) mem;
2162 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_lockup_checked_args_t);
2163 0 : fd_lockup_checked_args_new(mem);
2164 0 : {
2165 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
2166 0 : if( !is_null ) {
2167 0 : self->unix_timestamp = (long *) *alloc_mem;
2168 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(long);
2169 0 : LLVMFuzzerMutate( (uchar *)self->unix_timestamp, sizeof(long), sizeof(long) );
2170 0 : }
2171 0 : else {
2172 0 : self->unix_timestamp = NULL;
2173 0 : }
2174 0 : }
2175 0 : {
2176 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
2177 0 : if( !is_null ) {
2178 0 : self->epoch = (ulong *) *alloc_mem;
2179 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong);
2180 0 : LLVMFuzzerMutate( (uchar *)self->epoch, sizeof(ulong), sizeof(ulong) );
2181 0 : }
2182 0 : else {
2183 0 : self->epoch = NULL;
2184 0 : }
2185 0 : }
2186 0 : return mem;
2187 0 : }
2188 :
2189 0 : void *fd_lockup_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2190 0 : fd_lockup_args_t *self = (fd_lockup_args_t *) mem;
2191 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_lockup_args_t);
2192 0 : fd_lockup_args_new(mem);
2193 0 : {
2194 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
2195 0 : if( !is_null ) {
2196 0 : self->unix_timestamp = (long *) *alloc_mem;
2197 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(long);
2198 0 : LLVMFuzzerMutate( (uchar *)self->unix_timestamp, sizeof(long), sizeof(long) );
2199 0 : }
2200 0 : else {
2201 0 : self->unix_timestamp = NULL;
2202 0 : }
2203 0 : }
2204 0 : {
2205 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
2206 0 : if( !is_null ) {
2207 0 : self->epoch = (ulong *) *alloc_mem;
2208 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong);
2209 0 : LLVMFuzzerMutate( (uchar *)self->epoch, sizeof(ulong), sizeof(ulong) );
2210 0 : }
2211 0 : else {
2212 0 : self->epoch = NULL;
2213 0 : }
2214 0 : }
2215 0 : {
2216 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
2217 0 : if( !is_null ) {
2218 0 : self->custodian = (fd_pubkey_t *) *alloc_mem;
2219 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t);
2220 0 : fd_pubkey_new( self->custodian );
2221 0 : fd_pubkey_generate( self->custodian, alloc_mem, rng );
2222 0 : }
2223 0 : else {
2224 0 : self->custodian = NULL;
2225 0 : }
2226 0 : }
2227 0 : return mem;
2228 0 : }
2229 :
2230 0 : void fd_stake_instruction_inner_generate( fd_stake_instruction_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2231 0 : switch (discriminant) {
2232 0 : case 0: {
2233 0 : fd_stake_instruction_initialize_generate( &self->initialize, alloc_mem, rng );
2234 0 : break;
2235 0 : }
2236 0 : case 1: {
2237 0 : fd_stake_instruction_authorize_generate( &self->authorize, alloc_mem, rng );
2238 0 : break;
2239 0 : }
2240 0 : case 3: {
2241 0 : self->split = fd_rng_ulong( rng );
2242 0 : break;
2243 0 : }
2244 0 : case 4: {
2245 0 : self->withdraw = fd_rng_ulong( rng );
2246 0 : break;
2247 0 : }
2248 0 : case 6: {
2249 0 : fd_lockup_args_generate( &self->set_lockup, alloc_mem, rng );
2250 0 : break;
2251 0 : }
2252 0 : case 8: {
2253 0 : fd_authorize_with_seed_args_generate( &self->authorize_with_seed, alloc_mem, rng );
2254 0 : break;
2255 0 : }
2256 0 : case 10: {
2257 0 : fd_stake_authorize_generate( &self->authorize_checked, alloc_mem, rng );
2258 0 : break;
2259 0 : }
2260 0 : case 11: {
2261 0 : fd_authorize_checked_with_seed_args_generate( &self->authorize_checked_with_seed, alloc_mem, rng );
2262 0 : break;
2263 0 : }
2264 0 : case 12: {
2265 0 : fd_lockup_checked_args_generate( &self->set_lockup_checked, alloc_mem, rng );
2266 0 : break;
2267 0 : }
2268 0 : case 16: {
2269 0 : self->move_stake = fd_rng_ulong( rng );
2270 0 : break;
2271 0 : }
2272 0 : case 17: {
2273 0 : self->move_lamports = fd_rng_ulong( rng );
2274 0 : break;
2275 0 : }
2276 0 : }
2277 0 : }
2278 0 : void *fd_stake_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2279 0 : fd_stake_instruction_t *self = (fd_stake_instruction_t *) mem;
2280 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_instruction_t);
2281 0 : fd_stake_instruction_new(mem);
2282 0 : self->discriminant = fd_rng_uint( rng ) % 18;
2283 0 : fd_stake_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2284 0 : return mem;
2285 0 : }
2286 :
2287 0 : void *fd_stake_meta_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2288 0 : fd_stake_meta_t *self = (fd_stake_meta_t *) mem;
2289 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_meta_t);
2290 0 : fd_stake_meta_new(mem);
2291 0 : self->rent_exempt_reserve = fd_rng_ulong( rng );
2292 0 : fd_stake_authorized_generate( &self->authorized, alloc_mem, rng );
2293 0 : fd_stake_lockup_generate( &self->lockup, alloc_mem, rng );
2294 0 : return mem;
2295 0 : }
2296 :
2297 0 : void *fd_stake_flags_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2298 0 : fd_stake_flags_t *self = (fd_stake_flags_t *) mem;
2299 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_flags_t);
2300 0 : fd_stake_flags_new(mem);
2301 0 : self->bits = fd_rng_uchar( rng );
2302 0 : return mem;
2303 0 : }
2304 :
2305 0 : void *fd_stake_state_v2_initialized_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2306 0 : fd_stake_state_v2_initialized_t *self = (fd_stake_state_v2_initialized_t *) mem;
2307 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_state_v2_initialized_t);
2308 0 : fd_stake_state_v2_initialized_new(mem);
2309 0 : fd_stake_meta_generate( &self->meta, alloc_mem, rng );
2310 0 : return mem;
2311 0 : }
2312 :
2313 0 : void *fd_stake_state_v2_stake_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2314 0 : fd_stake_state_v2_stake_t *self = (fd_stake_state_v2_stake_t *) mem;
2315 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_state_v2_stake_t);
2316 0 : fd_stake_state_v2_stake_new(mem);
2317 0 : fd_stake_meta_generate( &self->meta, alloc_mem, rng );
2318 0 : fd_stake_generate( &self->stake, alloc_mem, rng );
2319 0 : fd_stake_flags_generate( &self->stake_flags, alloc_mem, rng );
2320 0 : return mem;
2321 0 : }
2322 :
2323 0 : void fd_stake_state_v2_inner_generate( fd_stake_state_v2_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2324 0 : switch (discriminant) {
2325 0 : case 1: {
2326 0 : fd_stake_state_v2_initialized_generate( &self->initialized, alloc_mem, rng );
2327 0 : break;
2328 0 : }
2329 0 : case 2: {
2330 0 : fd_stake_state_v2_stake_generate( &self->stake, alloc_mem, rng );
2331 0 : break;
2332 0 : }
2333 0 : }
2334 0 : }
2335 0 : void *fd_stake_state_v2_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2336 0 : fd_stake_state_v2_t *self = (fd_stake_state_v2_t *) mem;
2337 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_state_v2_t);
2338 0 : fd_stake_state_v2_new(mem);
2339 0 : self->discriminant = fd_rng_uint( rng ) % 4;
2340 0 : fd_stake_state_v2_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2341 0 : return mem;
2342 0 : }
2343 :
2344 0 : void *fd_nonce_data_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2345 0 : fd_nonce_data_t *self = (fd_nonce_data_t *) mem;
2346 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_nonce_data_t);
2347 0 : fd_nonce_data_new(mem);
2348 0 : fd_pubkey_generate( &self->authority, alloc_mem, rng );
2349 0 : fd_hash_generate( &self->durable_nonce, alloc_mem, rng );
2350 0 : fd_fee_calculator_generate( &self->fee_calculator, alloc_mem, rng );
2351 0 : return mem;
2352 0 : }
2353 :
2354 0 : void fd_nonce_state_inner_generate( fd_nonce_state_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2355 0 : switch (discriminant) {
2356 0 : case 1: {
2357 0 : fd_nonce_data_generate( &self->initialized, alloc_mem, rng );
2358 0 : break;
2359 0 : }
2360 0 : }
2361 0 : }
2362 0 : void *fd_nonce_state_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2363 0 : fd_nonce_state_t *self = (fd_nonce_state_t *) mem;
2364 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_nonce_state_t);
2365 0 : fd_nonce_state_new(mem);
2366 0 : self->discriminant = fd_rng_uint( rng ) % 2;
2367 0 : fd_nonce_state_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2368 0 : return mem;
2369 0 : }
2370 :
2371 0 : void fd_nonce_state_versions_inner_generate( fd_nonce_state_versions_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2372 0 : switch (discriminant) {
2373 0 : case 0: {
2374 0 : fd_nonce_state_generate( &self->legacy, alloc_mem, rng );
2375 0 : break;
2376 0 : }
2377 0 : case 1: {
2378 0 : fd_nonce_state_generate( &self->current, alloc_mem, rng );
2379 0 : break;
2380 0 : }
2381 0 : }
2382 0 : }
2383 0 : void *fd_nonce_state_versions_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2384 0 : fd_nonce_state_versions_t *self = (fd_nonce_state_versions_t *) mem;
2385 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_nonce_state_versions_t);
2386 0 : fd_nonce_state_versions_new(mem);
2387 0 : self->discriminant = fd_rng_uint( rng ) % 2;
2388 0 : fd_nonce_state_versions_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2389 0 : return mem;
2390 0 : }
2391 :
2392 0 : void *fd_compute_budget_program_instruction_request_units_deprecated_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2393 0 : fd_compute_budget_program_instruction_request_units_deprecated_t *self = (fd_compute_budget_program_instruction_request_units_deprecated_t *) mem;
2394 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_compute_budget_program_instruction_request_units_deprecated_t);
2395 0 : fd_compute_budget_program_instruction_request_units_deprecated_new(mem);
2396 0 : self->units = fd_rng_uint( rng );
2397 0 : self->additional_fee = fd_rng_uint( rng );
2398 0 : return mem;
2399 0 : }
2400 :
2401 0 : void fd_compute_budget_program_instruction_inner_generate( fd_compute_budget_program_instruction_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2402 0 : switch (discriminant) {
2403 0 : case 0: {
2404 0 : fd_compute_budget_program_instruction_request_units_deprecated_generate( &self->request_units_deprecated, alloc_mem, rng );
2405 0 : break;
2406 0 : }
2407 0 : case 1: {
2408 0 : self->request_heap_frame = fd_rng_uint( rng );
2409 0 : break;
2410 0 : }
2411 0 : case 2: {
2412 0 : self->set_compute_unit_limit = fd_rng_uint( rng );
2413 0 : break;
2414 0 : }
2415 0 : case 3: {
2416 0 : self->set_compute_unit_price = fd_rng_ulong( rng );
2417 0 : break;
2418 0 : }
2419 0 : case 4: {
2420 0 : self->set_loaded_accounts_data_size_limit = fd_rng_uint( rng );
2421 0 : break;
2422 0 : }
2423 0 : }
2424 0 : }
2425 0 : void *fd_compute_budget_program_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2426 0 : fd_compute_budget_program_instruction_t *self = (fd_compute_budget_program_instruction_t *) mem;
2427 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_compute_budget_program_instruction_t);
2428 0 : fd_compute_budget_program_instruction_new(mem);
2429 0 : self->discriminant = fd_rng_uint( rng ) % 5;
2430 0 : fd_compute_budget_program_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2431 0 : return mem;
2432 0 : }
2433 :
2434 0 : void *fd_config_keys_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2435 0 : fd_config_keys_t *self = (fd_config_keys_t *) mem;
2436 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_config_keys_t);
2437 0 : fd_config_keys_new(mem);
2438 0 : self->keys_len = fd_rng_ulong( rng ) % 8;
2439 0 : if( self->keys_len ) {
2440 0 : self->keys = (fd_config_keys_pair_t *) *alloc_mem;
2441 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_config_keys_pair_t)*self->keys_len;
2442 0 : for( ulong i=0; i < self->keys_len; i++ ) {
2443 0 : fd_config_keys_pair_new( self->keys + i );
2444 0 : fd_config_keys_pair_generate( self->keys + i, alloc_mem, rng );
2445 0 : }
2446 0 : } else {
2447 0 : self->keys = NULL;
2448 0 : }
2449 0 : return mem;
2450 0 : }
2451 :
2452 0 : void *fd_bpf_loader_program_instruction_write_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2453 0 : fd_bpf_loader_program_instruction_write_t *self = (fd_bpf_loader_program_instruction_write_t *) mem;
2454 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_loader_program_instruction_write_t);
2455 0 : fd_bpf_loader_program_instruction_write_new(mem);
2456 0 : self->offset = fd_rng_uint( rng );
2457 0 : self->bytes_len = fd_rng_ulong( rng ) % 8;
2458 0 : if( self->bytes_len ) {
2459 0 : self->bytes = (uchar *) *alloc_mem;
2460 0 : *alloc_mem = (uchar *) *alloc_mem + self->bytes_len;
2461 0 : for( ulong i=0; i < self->bytes_len; ++i) { self->bytes[i] = fd_rng_uchar( rng ) % 0x80; }
2462 0 : } else {
2463 0 : self->bytes = NULL;
2464 0 : }
2465 0 : return mem;
2466 0 : }
2467 :
2468 0 : void fd_bpf_loader_program_instruction_inner_generate( fd_bpf_loader_program_instruction_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2469 0 : switch (discriminant) {
2470 0 : case 0: {
2471 0 : fd_bpf_loader_program_instruction_write_generate( &self->write, alloc_mem, rng );
2472 0 : break;
2473 0 : }
2474 0 : }
2475 0 : }
2476 0 : void *fd_bpf_loader_program_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2477 0 : fd_bpf_loader_program_instruction_t *self = (fd_bpf_loader_program_instruction_t *) mem;
2478 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_loader_program_instruction_t);
2479 0 : fd_bpf_loader_program_instruction_new(mem);
2480 0 : self->discriminant = fd_rng_uint( rng ) % 2;
2481 0 : fd_bpf_loader_program_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2482 0 : return mem;
2483 0 : }
2484 :
2485 0 : void *fd_loader_v4_program_instruction_write_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2486 0 : fd_loader_v4_program_instruction_write_t *self = (fd_loader_v4_program_instruction_write_t *) mem;
2487 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_loader_v4_program_instruction_write_t);
2488 0 : fd_loader_v4_program_instruction_write_new(mem);
2489 0 : self->offset = fd_rng_uint( rng );
2490 0 : self->bytes_len = fd_rng_ulong( rng ) % 8;
2491 0 : if( self->bytes_len ) {
2492 0 : self->bytes = (uchar *) *alloc_mem;
2493 0 : *alloc_mem = (uchar *) *alloc_mem + self->bytes_len;
2494 0 : for( ulong i=0; i < self->bytes_len; ++i) { self->bytes[i] = fd_rng_uchar( rng ) % 0x80; }
2495 0 : } else {
2496 0 : self->bytes = NULL;
2497 0 : }
2498 0 : return mem;
2499 0 : }
2500 :
2501 0 : void *fd_loader_v4_program_instruction_copy_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2502 0 : fd_loader_v4_program_instruction_copy_t *self = (fd_loader_v4_program_instruction_copy_t *) mem;
2503 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_loader_v4_program_instruction_copy_t);
2504 0 : fd_loader_v4_program_instruction_copy_new(mem);
2505 0 : self->destination_offset = fd_rng_uint( rng );
2506 0 : self->source_offset = fd_rng_uint( rng );
2507 0 : self->length = fd_rng_uint( rng );
2508 0 : return mem;
2509 0 : }
2510 :
2511 0 : void *fd_loader_v4_program_instruction_set_program_length_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2512 0 : fd_loader_v4_program_instruction_set_program_length_t *self = (fd_loader_v4_program_instruction_set_program_length_t *) mem;
2513 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_loader_v4_program_instruction_set_program_length_t);
2514 0 : fd_loader_v4_program_instruction_set_program_length_new(mem);
2515 0 : self->new_size = fd_rng_uint( rng );
2516 0 : return mem;
2517 0 : }
2518 :
2519 0 : void fd_loader_v4_program_instruction_inner_generate( fd_loader_v4_program_instruction_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2520 0 : switch (discriminant) {
2521 0 : case 0: {
2522 0 : fd_loader_v4_program_instruction_write_generate( &self->write, alloc_mem, rng );
2523 0 : break;
2524 0 : }
2525 0 : case 1: {
2526 0 : fd_loader_v4_program_instruction_copy_generate( &self->copy, alloc_mem, rng );
2527 0 : break;
2528 0 : }
2529 0 : case 2: {
2530 0 : fd_loader_v4_program_instruction_set_program_length_generate( &self->set_program_length, alloc_mem, rng );
2531 0 : break;
2532 0 : }
2533 0 : }
2534 0 : }
2535 0 : void *fd_loader_v4_program_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2536 0 : fd_loader_v4_program_instruction_t *self = (fd_loader_v4_program_instruction_t *) mem;
2537 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_loader_v4_program_instruction_t);
2538 0 : fd_loader_v4_program_instruction_new(mem);
2539 0 : self->discriminant = fd_rng_uint( rng ) % 7;
2540 0 : fd_loader_v4_program_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2541 0 : return mem;
2542 0 : }
2543 :
2544 0 : void *fd_bpf_upgradeable_loader_program_instruction_write_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2545 0 : fd_bpf_upgradeable_loader_program_instruction_write_t *self = (fd_bpf_upgradeable_loader_program_instruction_write_t *) mem;
2546 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_write_t);
2547 0 : fd_bpf_upgradeable_loader_program_instruction_write_new(mem);
2548 0 : self->offset = fd_rng_uint( rng );
2549 0 : self->bytes_len = fd_rng_ulong( rng ) % 8;
2550 0 : if( self->bytes_len ) {
2551 0 : self->bytes = (uchar *) *alloc_mem;
2552 0 : *alloc_mem = (uchar *) *alloc_mem + self->bytes_len;
2553 0 : for( ulong i=0; i < self->bytes_len; ++i) { self->bytes[i] = fd_rng_uchar( rng ) % 0x80; }
2554 0 : } else {
2555 0 : self->bytes = NULL;
2556 0 : }
2557 0 : return mem;
2558 0 : }
2559 :
2560 0 : void *fd_bpf_upgradeable_loader_program_instruction_deploy_with_max_data_len_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2561 0 : fd_bpf_upgradeable_loader_program_instruction_deploy_with_max_data_len_t *self = (fd_bpf_upgradeable_loader_program_instruction_deploy_with_max_data_len_t *) mem;
2562 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_deploy_with_max_data_len_t);
2563 0 : fd_bpf_upgradeable_loader_program_instruction_deploy_with_max_data_len_new(mem);
2564 0 : self->max_data_len = fd_rng_ulong( rng );
2565 0 : return mem;
2566 0 : }
2567 :
2568 0 : void *fd_bpf_upgradeable_loader_program_instruction_extend_program_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2569 0 : fd_bpf_upgradeable_loader_program_instruction_extend_program_t *self = (fd_bpf_upgradeable_loader_program_instruction_extend_program_t *) mem;
2570 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_extend_program_t);
2571 0 : fd_bpf_upgradeable_loader_program_instruction_extend_program_new(mem);
2572 0 : self->additional_bytes = fd_rng_uint( rng );
2573 0 : return mem;
2574 0 : }
2575 :
2576 0 : void *fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2577 0 : fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t *self = (fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t *) mem;
2578 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t);
2579 0 : fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_new(mem);
2580 0 : self->additional_bytes = fd_rng_uint( rng );
2581 0 : return mem;
2582 0 : }
2583 :
2584 0 : void fd_bpf_upgradeable_loader_program_instruction_inner_generate( fd_bpf_upgradeable_loader_program_instruction_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2585 0 : switch (discriminant) {
2586 0 : case 1: {
2587 0 : fd_bpf_upgradeable_loader_program_instruction_write_generate( &self->write, alloc_mem, rng );
2588 0 : break;
2589 0 : }
2590 0 : case 2: {
2591 0 : fd_bpf_upgradeable_loader_program_instruction_deploy_with_max_data_len_generate( &self->deploy_with_max_data_len, alloc_mem, rng );
2592 0 : break;
2593 0 : }
2594 0 : case 6: {
2595 0 : fd_bpf_upgradeable_loader_program_instruction_extend_program_generate( &self->extend_program, alloc_mem, rng );
2596 0 : break;
2597 0 : }
2598 0 : case 9: {
2599 0 : fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_generate( &self->extend_program_checked, alloc_mem, rng );
2600 0 : break;
2601 0 : }
2602 0 : }
2603 0 : }
2604 0 : void *fd_bpf_upgradeable_loader_program_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2605 0 : fd_bpf_upgradeable_loader_program_instruction_t *self = (fd_bpf_upgradeable_loader_program_instruction_t *) mem;
2606 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_t);
2607 0 : fd_bpf_upgradeable_loader_program_instruction_new(mem);
2608 0 : self->discriminant = fd_rng_uint( rng ) % 10;
2609 0 : fd_bpf_upgradeable_loader_program_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2610 0 : return mem;
2611 0 : }
2612 :
2613 0 : void *fd_bpf_upgradeable_loader_state_buffer_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2614 0 : fd_bpf_upgradeable_loader_state_buffer_t *self = (fd_bpf_upgradeable_loader_state_buffer_t *) mem;
2615 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_state_buffer_t);
2616 0 : fd_bpf_upgradeable_loader_state_buffer_new(mem);
2617 0 : {
2618 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
2619 0 : if( !is_null ) {
2620 0 : self->authority_address = (fd_pubkey_t *) *alloc_mem;
2621 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t);
2622 0 : fd_pubkey_new( self->authority_address );
2623 0 : fd_pubkey_generate( self->authority_address, alloc_mem, rng );
2624 0 : }
2625 0 : else {
2626 0 : self->authority_address = NULL;
2627 0 : }
2628 0 : }
2629 0 : return mem;
2630 0 : }
2631 :
2632 0 : void *fd_bpf_upgradeable_loader_state_program_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2633 0 : fd_bpf_upgradeable_loader_state_program_t *self = (fd_bpf_upgradeable_loader_state_program_t *) mem;
2634 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_state_program_t);
2635 0 : fd_bpf_upgradeable_loader_state_program_new(mem);
2636 0 : fd_pubkey_generate( &self->programdata_address, alloc_mem, rng );
2637 0 : return mem;
2638 0 : }
2639 :
2640 0 : void *fd_bpf_upgradeable_loader_state_program_data_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2641 0 : fd_bpf_upgradeable_loader_state_program_data_t *self = (fd_bpf_upgradeable_loader_state_program_data_t *) mem;
2642 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_state_program_data_t);
2643 0 : fd_bpf_upgradeable_loader_state_program_data_new(mem);
2644 0 : self->slot = fd_rng_ulong( rng );
2645 0 : {
2646 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
2647 0 : if( !is_null ) {
2648 0 : self->upgrade_authority_address = (fd_pubkey_t *) *alloc_mem;
2649 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t);
2650 0 : fd_pubkey_new( self->upgrade_authority_address );
2651 0 : fd_pubkey_generate( self->upgrade_authority_address, alloc_mem, rng );
2652 0 : }
2653 0 : else {
2654 0 : self->upgrade_authority_address = NULL;
2655 0 : }
2656 0 : }
2657 0 : return mem;
2658 0 : }
2659 :
2660 0 : void fd_bpf_upgradeable_loader_state_inner_generate( fd_bpf_upgradeable_loader_state_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2661 0 : switch (discriminant) {
2662 0 : case 1: {
2663 0 : fd_bpf_upgradeable_loader_state_buffer_generate( &self->buffer, alloc_mem, rng );
2664 0 : break;
2665 0 : }
2666 0 : case 2: {
2667 0 : fd_bpf_upgradeable_loader_state_program_generate( &self->program, alloc_mem, rng );
2668 0 : break;
2669 0 : }
2670 0 : case 3: {
2671 0 : fd_bpf_upgradeable_loader_state_program_data_generate( &self->program_data, alloc_mem, rng );
2672 0 : break;
2673 0 : }
2674 0 : }
2675 0 : }
2676 0 : void *fd_bpf_upgradeable_loader_state_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2677 0 : fd_bpf_upgradeable_loader_state_t *self = (fd_bpf_upgradeable_loader_state_t *) mem;
2678 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_state_t);
2679 0 : fd_bpf_upgradeable_loader_state_new(mem);
2680 0 : self->discriminant = fd_rng_uint( rng ) % 4;
2681 0 : fd_bpf_upgradeable_loader_state_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2682 0 : return mem;
2683 0 : }
2684 :
2685 0 : void *fd_loader_v4_state_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2686 0 : fd_loader_v4_state_t *self = (fd_loader_v4_state_t *) mem;
2687 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_loader_v4_state_t);
2688 0 : fd_loader_v4_state_new(mem);
2689 0 : self->slot = fd_rng_ulong( rng );
2690 0 : fd_pubkey_generate( &self->authority_address_or_next_version, alloc_mem, rng );
2691 0 : self->status = fd_rng_ulong( rng );
2692 0 : return mem;
2693 0 : }
2694 :
2695 0 : void *fd_frozen_hash_status_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2696 0 : fd_frozen_hash_status_t *self = (fd_frozen_hash_status_t *) mem;
2697 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_frozen_hash_status_t);
2698 0 : fd_frozen_hash_status_new(mem);
2699 0 : fd_hash_generate( &self->frozen_hash, alloc_mem, rng );
2700 0 : self->is_duplicate_confirmed = fd_rng_uchar( rng );
2701 0 : return mem;
2702 0 : }
2703 :
2704 0 : void fd_frozen_hash_versioned_inner_generate( fd_frozen_hash_versioned_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2705 0 : switch (discriminant) {
2706 0 : case 0: {
2707 0 : fd_frozen_hash_status_generate( &self->current, alloc_mem, rng );
2708 0 : break;
2709 0 : }
2710 0 : }
2711 0 : }
2712 0 : void *fd_frozen_hash_versioned_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2713 0 : fd_frozen_hash_versioned_t *self = (fd_frozen_hash_versioned_t *) mem;
2714 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_frozen_hash_versioned_t);
2715 0 : fd_frozen_hash_versioned_new(mem);
2716 0 : self->discriminant = fd_rng_uint( rng ) % 1;
2717 0 : fd_frozen_hash_versioned_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2718 0 : return mem;
2719 0 : }
2720 :
2721 0 : void *fd_lookup_table_meta_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2722 0 : fd_lookup_table_meta_t *self = (fd_lookup_table_meta_t *) mem;
2723 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_lookup_table_meta_t);
2724 0 : fd_lookup_table_meta_new(mem);
2725 0 : self->deactivation_slot = fd_rng_ulong( rng );
2726 0 : self->last_extended_slot = fd_rng_ulong( rng );
2727 0 : self->last_extended_slot_start_index = fd_rng_uchar( rng );
2728 0 : {
2729 0 : self->has_authority = fd_rng_uchar( rng ) % 2;
2730 0 : if( self->has_authority ) {
2731 0 : fd_pubkey_generate( &self->authority, alloc_mem, rng );
2732 0 : }
2733 0 : }
2734 0 : self->_padding = fd_rng_ushort( rng );
2735 0 : return mem;
2736 0 : }
2737 :
2738 0 : void *fd_address_lookup_table_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2739 0 : fd_address_lookup_table_t *self = (fd_address_lookup_table_t *) mem;
2740 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_address_lookup_table_t);
2741 0 : fd_address_lookup_table_new(mem);
2742 0 : fd_lookup_table_meta_generate( &self->meta, alloc_mem, rng );
2743 0 : return mem;
2744 0 : }
2745 :
2746 0 : void fd_address_lookup_table_state_inner_generate( fd_address_lookup_table_state_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2747 0 : switch (discriminant) {
2748 0 : case 1: {
2749 0 : fd_address_lookup_table_generate( &self->lookup_table, alloc_mem, rng );
2750 0 : break;
2751 0 : }
2752 0 : }
2753 0 : }
2754 0 : void *fd_address_lookup_table_state_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2755 0 : fd_address_lookup_table_state_t *self = (fd_address_lookup_table_state_t *) mem;
2756 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_address_lookup_table_state_t);
2757 0 : fd_address_lookup_table_state_new(mem);
2758 0 : self->discriminant = fd_rng_uint( rng ) % 2;
2759 0 : fd_address_lookup_table_state_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2760 0 : return mem;
2761 0 : }
2762 :
2763 0 : void *fd_gossip_ping_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2764 0 : fd_gossip_ping_t *self = (fd_gossip_ping_t *) mem;
2765 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_ping_t);
2766 0 : fd_gossip_ping_new(mem);
2767 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
2768 0 : fd_hash_generate( &self->token, alloc_mem, rng );
2769 0 : fd_signature_generate( &self->signature, alloc_mem, rng );
2770 0 : return mem;
2771 0 : }
2772 :
2773 0 : void fd_gossip_ip_addr_inner_generate( fd_gossip_ip_addr_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2774 0 : switch (discriminant) {
2775 0 : case 0: {
2776 0 : fd_gossip_ip4_addr_generate( &self->ip4, alloc_mem, rng );
2777 0 : break;
2778 0 : }
2779 0 : case 1: {
2780 0 : fd_gossip_ip6_addr_generate( &self->ip6, alloc_mem, rng );
2781 0 : break;
2782 0 : }
2783 0 : }
2784 0 : }
2785 0 : void *fd_gossip_ip_addr_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2786 0 : fd_gossip_ip_addr_t *self = (fd_gossip_ip_addr_t *) mem;
2787 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_ip_addr_t);
2788 0 : fd_gossip_ip_addr_new(mem);
2789 0 : self->discriminant = fd_rng_uint( rng ) % 2;
2790 0 : fd_gossip_ip_addr_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2791 0 : return mem;
2792 0 : }
2793 :
2794 0 : void *fd_gossip_prune_data_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2795 0 : fd_gossip_prune_data_t *self = (fd_gossip_prune_data_t *) mem;
2796 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_prune_data_t);
2797 0 : fd_gossip_prune_data_new(mem);
2798 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
2799 0 : self->prunes_len = fd_rng_ulong( rng ) % 8;
2800 0 : if( self->prunes_len ) {
2801 0 : self->prunes = (fd_pubkey_t *) *alloc_mem;
2802 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t)*self->prunes_len;
2803 0 : for( ulong i=0; i < self->prunes_len; i++ ) {
2804 0 : fd_pubkey_new( self->prunes + i );
2805 0 : fd_pubkey_generate( self->prunes + i, alloc_mem, rng );
2806 0 : }
2807 0 : } else {
2808 0 : self->prunes = NULL;
2809 0 : }
2810 0 : fd_signature_generate( &self->signature, alloc_mem, rng );
2811 0 : fd_pubkey_generate( &self->destination, alloc_mem, rng );
2812 0 : self->wallclock = fd_rng_ulong( rng );
2813 0 : return mem;
2814 0 : }
2815 :
2816 0 : void *fd_gossip_prune_sign_data_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2817 0 : fd_gossip_prune_sign_data_t *self = (fd_gossip_prune_sign_data_t *) mem;
2818 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_prune_sign_data_t);
2819 0 : fd_gossip_prune_sign_data_new(mem);
2820 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
2821 0 : self->prunes_len = fd_rng_ulong( rng ) % 8;
2822 0 : if( self->prunes_len ) {
2823 0 : self->prunes = (fd_pubkey_t *) *alloc_mem;
2824 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t)*self->prunes_len;
2825 0 : for( ulong i=0; i < self->prunes_len; i++ ) {
2826 0 : fd_pubkey_new( self->prunes + i );
2827 0 : fd_pubkey_generate( self->prunes + i, alloc_mem, rng );
2828 0 : }
2829 0 : } else {
2830 0 : self->prunes = NULL;
2831 0 : }
2832 0 : fd_pubkey_generate( &self->destination, alloc_mem, rng );
2833 0 : self->wallclock = fd_rng_ulong( rng );
2834 0 : return mem;
2835 0 : }
2836 :
2837 0 : void *fd_gossip_prune_sign_data_with_prefix_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2838 0 : fd_gossip_prune_sign_data_with_prefix_t *self = (fd_gossip_prune_sign_data_with_prefix_t *) mem;
2839 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_prune_sign_data_with_prefix_t);
2840 0 : fd_gossip_prune_sign_data_with_prefix_new(mem);
2841 0 : self->prefix_len = fd_rng_ulong( rng ) % 8;
2842 0 : if( self->prefix_len ) {
2843 0 : self->prefix = (uchar *) *alloc_mem;
2844 0 : *alloc_mem = (uchar *) *alloc_mem + self->prefix_len;
2845 0 : for( ulong i=0; i < self->prefix_len; ++i) { self->prefix[i] = fd_rng_uchar( rng ) % 0x80; }
2846 0 : } else {
2847 0 : self->prefix = NULL;
2848 0 : }
2849 0 : fd_gossip_prune_sign_data_generate( &self->data, alloc_mem, rng );
2850 0 : return mem;
2851 0 : }
2852 :
2853 0 : void *fd_gossip_socket_addr_old_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2854 0 : fd_gossip_socket_addr_old_t *self = (fd_gossip_socket_addr_old_t *) mem;
2855 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_socket_addr_old_t);
2856 0 : fd_gossip_socket_addr_old_new(mem);
2857 0 : fd_gossip_ip_addr_generate( &self->addr, alloc_mem, rng );
2858 0 : self->port = fd_rng_ushort( rng );
2859 0 : return mem;
2860 0 : }
2861 :
2862 0 : void *fd_gossip_socket_addr_ip4_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2863 0 : fd_gossip_socket_addr_ip4_t *self = (fd_gossip_socket_addr_ip4_t *) mem;
2864 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_socket_addr_ip4_t);
2865 0 : fd_gossip_socket_addr_ip4_new(mem);
2866 0 : fd_gossip_ip4_addr_generate( &self->addr, alloc_mem, rng );
2867 0 : self->port = fd_rng_ushort( rng );
2868 0 : return mem;
2869 0 : }
2870 :
2871 0 : void *fd_gossip_socket_addr_ip6_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2872 0 : fd_gossip_socket_addr_ip6_t *self = (fd_gossip_socket_addr_ip6_t *) mem;
2873 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_socket_addr_ip6_t);
2874 0 : fd_gossip_socket_addr_ip6_new(mem);
2875 0 : fd_gossip_ip6_addr_generate( &self->addr, alloc_mem, rng );
2876 0 : self->port = fd_rng_ushort( rng );
2877 0 : return mem;
2878 0 : }
2879 :
2880 0 : void fd_gossip_socket_addr_inner_generate( fd_gossip_socket_addr_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2881 0 : switch (discriminant) {
2882 0 : case 0: {
2883 0 : fd_gossip_socket_addr_ip4_generate( &self->ip4, alloc_mem, rng );
2884 0 : break;
2885 0 : }
2886 0 : case 1: {
2887 0 : fd_gossip_socket_addr_ip6_generate( &self->ip6, alloc_mem, rng );
2888 0 : break;
2889 0 : }
2890 0 : }
2891 0 : }
2892 0 : void *fd_gossip_socket_addr_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2893 0 : fd_gossip_socket_addr_t *self = (fd_gossip_socket_addr_t *) mem;
2894 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_socket_addr_t);
2895 0 : fd_gossip_socket_addr_new(mem);
2896 0 : self->discriminant = fd_rng_uint( rng ) % 2;
2897 0 : fd_gossip_socket_addr_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2898 0 : return mem;
2899 0 : }
2900 :
2901 0 : void *fd_gossip_contact_info_v1_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2902 0 : fd_gossip_contact_info_v1_t *self = (fd_gossip_contact_info_v1_t *) mem;
2903 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_contact_info_v1_t);
2904 0 : fd_gossip_contact_info_v1_new(mem);
2905 0 : fd_pubkey_generate( &self->id, alloc_mem, rng );
2906 0 : fd_gossip_socket_addr_generate( &self->gossip, alloc_mem, rng );
2907 0 : fd_gossip_socket_addr_generate( &self->tvu, alloc_mem, rng );
2908 0 : fd_gossip_socket_addr_generate( &self->tvu_fwd, alloc_mem, rng );
2909 0 : fd_gossip_socket_addr_generate( &self->repair, alloc_mem, rng );
2910 0 : fd_gossip_socket_addr_generate( &self->tpu, alloc_mem, rng );
2911 0 : fd_gossip_socket_addr_generate( &self->tpu_fwd, alloc_mem, rng );
2912 0 : fd_gossip_socket_addr_generate( &self->tpu_vote, alloc_mem, rng );
2913 0 : fd_gossip_socket_addr_generate( &self->rpc, alloc_mem, rng );
2914 0 : fd_gossip_socket_addr_generate( &self->rpc_pubsub, alloc_mem, rng );
2915 0 : fd_gossip_socket_addr_generate( &self->serve_repair, alloc_mem, rng );
2916 0 : self->wallclock = fd_rng_ulong( rng );
2917 0 : self->shred_version = fd_rng_ushort( rng );
2918 0 : return mem;
2919 0 : }
2920 :
2921 0 : void *fd_gossip_vote_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2922 0 : fd_gossip_vote_t *self = (fd_gossip_vote_t *) mem;
2923 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_vote_t);
2924 0 : fd_gossip_vote_new(mem);
2925 0 : self->index = fd_rng_uchar( rng );
2926 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
2927 0 : fd_flamenco_txn_generate( &self->txn, alloc_mem, rng );
2928 0 : self->wallclock = fd_rng_ulong( rng );
2929 0 : return mem;
2930 0 : }
2931 :
2932 0 : void *fd_gossip_deprecated_compression_type_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2933 0 : fd_gossip_deprecated_compression_type_t *self = (fd_gossip_deprecated_compression_type_t *) mem;
2934 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_deprecated_compression_type_t);
2935 0 : fd_gossip_deprecated_compression_type_new(mem);
2936 0 : self->discriminant = fd_rng_uint( rng ) % 3;
2937 0 : return mem;
2938 0 : }
2939 :
2940 0 : void *fd_gossip_deprecated_epoch_incomplete_slots_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2941 0 : fd_gossip_deprecated_epoch_incomplete_slots_t *self = (fd_gossip_deprecated_epoch_incomplete_slots_t *) mem;
2942 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_deprecated_epoch_incomplete_slots_t);
2943 0 : fd_gossip_deprecated_epoch_incomplete_slots_new(mem);
2944 0 : self->first = fd_rng_ulong( rng );
2945 0 : fd_gossip_deprecated_compression_type_generate( &self->compression, alloc_mem, rng );
2946 0 : self->compressed_list_len = fd_rng_ulong( rng ) % 8;
2947 0 : if( self->compressed_list_len ) {
2948 0 : self->compressed_list = (uchar *) *alloc_mem;
2949 0 : *alloc_mem = (uchar *) *alloc_mem + self->compressed_list_len;
2950 0 : for( ulong i=0; i < self->compressed_list_len; ++i) { self->compressed_list[i] = fd_rng_uchar( rng ) % 0x80; }
2951 0 : } else {
2952 0 : self->compressed_list = NULL;
2953 0 : }
2954 0 : return mem;
2955 0 : }
2956 :
2957 0 : void *fd_gossip_lowest_slot_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2958 0 : fd_gossip_lowest_slot_t *self = (fd_gossip_lowest_slot_t *) mem;
2959 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_lowest_slot_t);
2960 0 : fd_gossip_lowest_slot_new(mem);
2961 0 : self->u8 = fd_rng_uchar( rng );
2962 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
2963 0 : self->root = fd_rng_ulong( rng );
2964 0 : self->lowest = fd_rng_ulong( rng );
2965 0 : self->slots_len = fd_rng_ulong( rng ) % 8;
2966 0 : if( self->slots_len ) {
2967 0 : self->slots = (ulong *) *alloc_mem;
2968 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong)*self->slots_len;
2969 0 : LLVMFuzzerMutate( (uchar *) self->slots, sizeof(ulong)*self->slots_len, sizeof(ulong)*self->slots_len );
2970 0 : } else {
2971 0 : self->slots = NULL;
2972 0 : }
2973 0 : self->stash_len = fd_rng_ulong( rng ) % 8;
2974 0 : if( self->stash_len ) {
2975 0 : self->stash = (fd_gossip_deprecated_epoch_incomplete_slots_t *) *alloc_mem;
2976 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_deprecated_epoch_incomplete_slots_t)*self->stash_len;
2977 0 : for( ulong i=0; i < self->stash_len; i++ ) {
2978 0 : fd_gossip_deprecated_epoch_incomplete_slots_new( self->stash + i );
2979 0 : fd_gossip_deprecated_epoch_incomplete_slots_generate( self->stash + i, alloc_mem, rng );
2980 0 : }
2981 0 : } else {
2982 0 : self->stash = NULL;
2983 0 : }
2984 0 : self->wallclock = fd_rng_ulong( rng );
2985 0 : return mem;
2986 0 : }
2987 :
2988 0 : void *fd_gossip_slot_hashes_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2989 0 : fd_gossip_slot_hashes_t *self = (fd_gossip_slot_hashes_t *) mem;
2990 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_slot_hashes_t);
2991 0 : fd_gossip_slot_hashes_new(mem);
2992 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
2993 0 : self->hashes_len = fd_rng_ulong( rng ) % 8;
2994 0 : if( self->hashes_len ) {
2995 0 : self->hashes = (fd_slot_hash_t *) *alloc_mem;
2996 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_hash_t)*self->hashes_len;
2997 0 : for( ulong i=0; i < self->hashes_len; i++ ) {
2998 0 : fd_slot_hash_new( self->hashes + i );
2999 0 : fd_slot_hash_generate( self->hashes + i, alloc_mem, rng );
3000 0 : }
3001 0 : } else {
3002 0 : self->hashes = NULL;
3003 0 : }
3004 0 : self->wallclock = fd_rng_ulong( rng );
3005 0 : return mem;
3006 0 : }
3007 :
3008 0 : void *fd_gossip_slots_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3009 0 : fd_gossip_slots_t *self = (fd_gossip_slots_t *) mem;
3010 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_slots_t);
3011 0 : fd_gossip_slots_new(mem);
3012 0 : self->first_slot = fd_rng_ulong( rng );
3013 0 : self->num = fd_rng_ulong( rng );
3014 0 : {
3015 0 : self->has_slots = fd_rng_uchar( rng ) % 2;
3016 0 : if( self->has_slots ) {
3017 0 : self->slots_bitvec_len = fd_rng_ulong( rng ) % 8;
3018 0 : if( self->slots_bitvec_len ) {
3019 0 : self->slots_bitvec = (uchar *) *alloc_mem;
3020 0 : *alloc_mem = (uchar *) *alloc_mem + self->slots_bitvec_len;
3021 0 : for( ulong i=0; i < self->slots_bitvec_len; ++i) { self->slots_bitvec[i] = fd_rng_uchar( rng ) % 0x80; }
3022 0 : } else {
3023 0 : self->slots_bitvec = NULL;
3024 0 : }
3025 0 : self->slots_len = self->slots_bitvec_len;
3026 0 : } else {
3027 0 : self->slots_len = 0UL;
3028 0 : }
3029 0 : }
3030 0 : return mem;
3031 0 : }
3032 :
3033 0 : void *fd_gossip_flate2_slots_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3034 0 : fd_gossip_flate2_slots_t *self = (fd_gossip_flate2_slots_t *) mem;
3035 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_flate2_slots_t);
3036 0 : fd_gossip_flate2_slots_new(mem);
3037 0 : self->first_slot = fd_rng_ulong( rng );
3038 0 : self->num = fd_rng_ulong( rng );
3039 0 : self->compressed_len = fd_rng_ulong( rng ) % 8;
3040 0 : if( self->compressed_len ) {
3041 0 : self->compressed = (uchar *) *alloc_mem;
3042 0 : *alloc_mem = (uchar *) *alloc_mem + self->compressed_len;
3043 0 : for( ulong i=0; i < self->compressed_len; ++i) { self->compressed[i] = fd_rng_uchar( rng ) % 0x80; }
3044 0 : } else {
3045 0 : self->compressed = NULL;
3046 0 : }
3047 0 : return mem;
3048 0 : }
3049 :
3050 0 : void fd_gossip_slots_enum_inner_generate( fd_gossip_slots_enum_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
3051 0 : switch (discriminant) {
3052 0 : case 0: {
3053 0 : fd_gossip_flate2_slots_generate( &self->flate2, alloc_mem, rng );
3054 0 : break;
3055 0 : }
3056 0 : case 1: {
3057 0 : fd_gossip_slots_generate( &self->uncompressed, alloc_mem, rng );
3058 0 : break;
3059 0 : }
3060 0 : }
3061 0 : }
3062 0 : void *fd_gossip_slots_enum_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3063 0 : fd_gossip_slots_enum_t *self = (fd_gossip_slots_enum_t *) mem;
3064 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_slots_enum_t);
3065 0 : fd_gossip_slots_enum_new(mem);
3066 0 : self->discriminant = fd_rng_uint( rng ) % 2;
3067 0 : fd_gossip_slots_enum_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
3068 0 : return mem;
3069 0 : }
3070 :
3071 0 : void *fd_gossip_epoch_slots_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3072 0 : fd_gossip_epoch_slots_t *self = (fd_gossip_epoch_slots_t *) mem;
3073 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_epoch_slots_t);
3074 0 : fd_gossip_epoch_slots_new(mem);
3075 0 : self->u8 = fd_rng_uchar( rng );
3076 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
3077 0 : self->slots_len = fd_rng_ulong( rng ) % 8;
3078 0 : if( self->slots_len ) {
3079 0 : self->slots = (fd_gossip_slots_enum_t *) *alloc_mem;
3080 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_slots_enum_t)*self->slots_len;
3081 0 : for( ulong i=0; i < self->slots_len; i++ ) {
3082 0 : fd_gossip_slots_enum_new( self->slots + i );
3083 0 : fd_gossip_slots_enum_generate( self->slots + i, alloc_mem, rng );
3084 0 : }
3085 0 : } else {
3086 0 : self->slots = NULL;
3087 0 : }
3088 0 : self->wallclock = fd_rng_ulong( rng );
3089 0 : return mem;
3090 0 : }
3091 :
3092 0 : void *fd_gossip_version_v1_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3093 0 : fd_gossip_version_v1_t *self = (fd_gossip_version_v1_t *) mem;
3094 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_version_v1_t);
3095 0 : fd_gossip_version_v1_new(mem);
3096 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
3097 0 : self->wallclock = fd_rng_ulong( rng );
3098 0 : self->major = fd_rng_ushort( rng );
3099 0 : self->minor = fd_rng_ushort( rng );
3100 0 : self->patch = fd_rng_ushort( rng );
3101 0 : {
3102 0 : self->has_commit = fd_rng_uchar( rng ) % 2;
3103 0 : if( self->has_commit ) {
3104 0 : LLVMFuzzerMutate( (uchar *)&(self->commit), sizeof(uint), sizeof(uint) );
3105 0 : }
3106 0 : }
3107 0 : return mem;
3108 0 : }
3109 :
3110 0 : void *fd_gossip_version_v2_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3111 0 : fd_gossip_version_v2_t *self = (fd_gossip_version_v2_t *) mem;
3112 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_version_v2_t);
3113 0 : fd_gossip_version_v2_new(mem);
3114 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
3115 0 : self->wallclock = fd_rng_ulong( rng );
3116 0 : self->major = fd_rng_ushort( rng );
3117 0 : self->minor = fd_rng_ushort( rng );
3118 0 : self->patch = fd_rng_ushort( rng );
3119 0 : {
3120 0 : self->has_commit = fd_rng_uchar( rng ) % 2;
3121 0 : if( self->has_commit ) {
3122 0 : LLVMFuzzerMutate( (uchar *)&(self->commit), sizeof(uint), sizeof(uint) );
3123 0 : }
3124 0 : }
3125 0 : self->feature_set = fd_rng_uint( rng );
3126 0 : return mem;
3127 0 : }
3128 :
3129 0 : void *fd_gossip_version_v3_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3130 0 : fd_gossip_version_v3_t *self = (fd_gossip_version_v3_t *) mem;
3131 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_version_v3_t);
3132 0 : fd_gossip_version_v3_new(mem);
3133 0 : self->major = fd_rng_ushort( rng );
3134 0 : self->minor = fd_rng_ushort( rng );
3135 0 : self->patch = fd_rng_ushort( rng );
3136 0 : self->commit = fd_rng_uint( rng );
3137 0 : self->feature_set = fd_rng_uint( rng );
3138 0 : self->client = fd_rng_ushort( rng );
3139 0 : return mem;
3140 0 : }
3141 :
3142 0 : void *fd_gossip_node_instance_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3143 0 : fd_gossip_node_instance_t *self = (fd_gossip_node_instance_t *) mem;
3144 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_node_instance_t);
3145 0 : fd_gossip_node_instance_new(mem);
3146 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
3147 0 : self->wallclock = fd_rng_ulong( rng );
3148 0 : self->timestamp = fd_rng_ulong( rng );
3149 0 : self->token = fd_rng_ulong( rng );
3150 0 : return mem;
3151 0 : }
3152 :
3153 0 : void *fd_gossip_duplicate_shred_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3154 0 : fd_gossip_duplicate_shred_t *self = (fd_gossip_duplicate_shred_t *) mem;
3155 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_duplicate_shred_t);
3156 0 : fd_gossip_duplicate_shred_new(mem);
3157 0 : self->duplicate_shred_index = fd_rng_ushort( rng );
3158 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
3159 0 : self->wallclock = fd_rng_ulong( rng );
3160 0 : self->slot = fd_rng_ulong( rng );
3161 0 : self->_unused = fd_rng_uint( rng );
3162 0 : self->_unused_shred_type = fd_rng_uchar( rng );
3163 0 : self->num_chunks = fd_rng_uchar( rng );
3164 0 : self->chunk_index = fd_rng_uchar( rng );
3165 0 : self->chunk_len = fd_rng_ulong( rng ) % 8;
3166 0 : if( self->chunk_len ) {
3167 0 : self->chunk = (uchar *) *alloc_mem;
3168 0 : *alloc_mem = (uchar *) *alloc_mem + self->chunk_len;
3169 0 : for( ulong i=0; i < self->chunk_len; ++i) { self->chunk[i] = fd_rng_uchar( rng ) % 0x80; }
3170 0 : } else {
3171 0 : self->chunk = NULL;
3172 0 : }
3173 0 : return mem;
3174 0 : }
3175 :
3176 0 : void *fd_gossip_incremental_snapshot_hashes_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3177 0 : fd_gossip_incremental_snapshot_hashes_t *self = (fd_gossip_incremental_snapshot_hashes_t *) mem;
3178 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_incremental_snapshot_hashes_t);
3179 0 : fd_gossip_incremental_snapshot_hashes_new(mem);
3180 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
3181 0 : fd_slot_hash_generate( &self->base_hash, alloc_mem, rng );
3182 0 : self->hashes_len = fd_rng_ulong( rng ) % 8;
3183 0 : if( self->hashes_len ) {
3184 0 : self->hashes = (fd_slot_hash_t *) *alloc_mem;
3185 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_hash_t)*self->hashes_len;
3186 0 : for( ulong i=0; i < self->hashes_len; i++ ) {
3187 0 : fd_slot_hash_new( self->hashes + i );
3188 0 : fd_slot_hash_generate( self->hashes + i, alloc_mem, rng );
3189 0 : }
3190 0 : } else {
3191 0 : self->hashes = NULL;
3192 0 : }
3193 0 : self->wallclock = fd_rng_ulong( rng );
3194 0 : return mem;
3195 0 : }
3196 :
3197 0 : void *fd_gossip_socket_entry_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3198 0 : fd_gossip_socket_entry_t *self = (fd_gossip_socket_entry_t *) mem;
3199 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_socket_entry_t);
3200 0 : fd_gossip_socket_entry_new(mem);
3201 0 : self->key = fd_rng_uchar( rng );
3202 0 : self->index = fd_rng_uchar( rng );
3203 0 : self->offset = fd_rng_ushort( rng );
3204 0 : return mem;
3205 0 : }
3206 :
3207 0 : void *fd_gossip_contact_info_v2_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3208 0 : fd_gossip_contact_info_v2_t *self = (fd_gossip_contact_info_v2_t *) mem;
3209 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_contact_info_v2_t);
3210 0 : fd_gossip_contact_info_v2_new(mem);
3211 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
3212 0 : self->wallclock = fd_rng_ulong( rng );
3213 0 : self->outset = fd_rng_ulong( rng );
3214 0 : self->shred_version = fd_rng_ushort( rng );
3215 0 : fd_gossip_version_v3_generate( &self->version, alloc_mem, rng );
3216 0 : self->addrs_len = fd_rng_ulong( rng ) % 8;
3217 0 : if( self->addrs_len ) {
3218 0 : self->addrs = (fd_gossip_ip_addr_t *) *alloc_mem;
3219 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_ip_addr_t)*self->addrs_len;
3220 0 : for( ulong i=0; i < self->addrs_len; i++ ) {
3221 0 : fd_gossip_ip_addr_new( self->addrs + i );
3222 0 : fd_gossip_ip_addr_generate( self->addrs + i, alloc_mem, rng );
3223 0 : }
3224 0 : } else {
3225 0 : self->addrs = NULL;
3226 0 : }
3227 0 : self->sockets_len = fd_rng_ulong( rng ) % 8;
3228 0 : if( self->sockets_len ) {
3229 0 : self->sockets = (fd_gossip_socket_entry_t *) *alloc_mem;
3230 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_socket_entry_t)*self->sockets_len;
3231 0 : for( ulong i=0; i < self->sockets_len; i++ ) {
3232 0 : fd_gossip_socket_entry_new( self->sockets + i );
3233 0 : fd_gossip_socket_entry_generate( self->sockets + i, alloc_mem, rng );
3234 0 : }
3235 0 : } else {
3236 0 : self->sockets = NULL;
3237 0 : }
3238 0 : self->extensions_len = fd_rng_ulong( rng ) % 8;
3239 0 : if( self->extensions_len ) {
3240 0 : self->extensions = (uint *) *alloc_mem;
3241 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(uint)*self->extensions_len;
3242 0 : LLVMFuzzerMutate( (uchar *) self->extensions, sizeof(uint)*self->extensions_len, sizeof(uint)*self->extensions_len );
3243 0 : } else {
3244 0 : self->extensions = NULL;
3245 0 : }
3246 0 : return mem;
3247 0 : }
3248 :
3249 0 : void *fd_restart_run_length_encoding_inner_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3250 0 : fd_restart_run_length_encoding_inner_t *self = (fd_restart_run_length_encoding_inner_t *) mem;
3251 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_restart_run_length_encoding_inner_t);
3252 0 : fd_restart_run_length_encoding_inner_new(mem);
3253 0 : self->bits = fd_rng_ushort( rng );
3254 0 : return mem;
3255 0 : }
3256 :
3257 0 : void *fd_restart_run_length_encoding_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3258 0 : fd_restart_run_length_encoding_t *self = (fd_restart_run_length_encoding_t *) mem;
3259 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_restart_run_length_encoding_t);
3260 0 : fd_restart_run_length_encoding_new(mem);
3261 0 : self->offsets_len = fd_rng_ulong( rng ) % 8;
3262 0 : if( self->offsets_len ) {
3263 0 : self->offsets = (fd_restart_run_length_encoding_inner_t *) *alloc_mem;
3264 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_restart_run_length_encoding_inner_t)*self->offsets_len;
3265 0 : for( ulong i=0; i < self->offsets_len; i++ ) {
3266 0 : fd_restart_run_length_encoding_inner_new( self->offsets + i );
3267 0 : fd_restart_run_length_encoding_inner_generate( self->offsets + i, alloc_mem, rng );
3268 0 : }
3269 0 : } else {
3270 0 : self->offsets = NULL;
3271 0 : }
3272 0 : return mem;
3273 0 : }
3274 :
3275 0 : void *fd_restart_raw_offsets_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3276 0 : fd_restart_raw_offsets_t *self = (fd_restart_raw_offsets_t *) mem;
3277 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_restart_raw_offsets_t);
3278 0 : fd_restart_raw_offsets_new(mem);
3279 0 : {
3280 0 : self->has_offsets = fd_rng_uchar( rng ) % 2;
3281 0 : if( self->has_offsets ) {
3282 0 : self->offsets_bitvec_len = fd_rng_ulong( rng ) % 8;
3283 0 : if( self->offsets_bitvec_len ) {
3284 0 : self->offsets_bitvec = (uchar *) *alloc_mem;
3285 0 : *alloc_mem = (uchar *) *alloc_mem + self->offsets_bitvec_len;
3286 0 : for( ulong i=0; i < self->offsets_bitvec_len; ++i) { self->offsets_bitvec[i] = fd_rng_uchar( rng ) % 0x80; }
3287 0 : } else {
3288 0 : self->offsets_bitvec = NULL;
3289 0 : }
3290 0 : self->offsets_len = self->offsets_bitvec_len;
3291 0 : } else {
3292 0 : self->offsets_len = 0UL;
3293 0 : }
3294 0 : }
3295 0 : return mem;
3296 0 : }
3297 :
3298 0 : void fd_restart_slots_offsets_inner_generate( fd_restart_slots_offsets_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
3299 0 : switch (discriminant) {
3300 0 : case 0: {
3301 0 : fd_restart_run_length_encoding_generate( &self->run_length_encoding, alloc_mem, rng );
3302 0 : break;
3303 0 : }
3304 0 : case 1: {
3305 0 : fd_restart_raw_offsets_generate( &self->raw_offsets, alloc_mem, rng );
3306 0 : break;
3307 0 : }
3308 0 : }
3309 0 : }
3310 0 : void *fd_restart_slots_offsets_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3311 0 : fd_restart_slots_offsets_t *self = (fd_restart_slots_offsets_t *) mem;
3312 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_restart_slots_offsets_t);
3313 0 : fd_restart_slots_offsets_new(mem);
3314 0 : self->discriminant = fd_rng_uint( rng ) % 2;
3315 0 : fd_restart_slots_offsets_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
3316 0 : return mem;
3317 0 : }
3318 :
3319 0 : void *fd_gossip_restart_last_voted_fork_slots_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3320 0 : fd_gossip_restart_last_voted_fork_slots_t *self = (fd_gossip_restart_last_voted_fork_slots_t *) mem;
3321 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_restart_last_voted_fork_slots_t);
3322 0 : fd_gossip_restart_last_voted_fork_slots_new(mem);
3323 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
3324 0 : self->wallclock = fd_rng_ulong( rng );
3325 0 : fd_restart_slots_offsets_generate( &self->offsets, alloc_mem, rng );
3326 0 : self->last_voted_slot = fd_rng_ulong( rng );
3327 0 : fd_hash_generate( &self->last_voted_hash, alloc_mem, rng );
3328 0 : self->shred_version = fd_rng_ushort( rng );
3329 0 : return mem;
3330 0 : }
3331 :
3332 0 : void *fd_gossip_restart_heaviest_fork_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3333 0 : fd_gossip_restart_heaviest_fork_t *self = (fd_gossip_restart_heaviest_fork_t *) mem;
3334 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_restart_heaviest_fork_t);
3335 0 : fd_gossip_restart_heaviest_fork_new(mem);
3336 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
3337 0 : self->wallclock = fd_rng_ulong( rng );
3338 0 : self->last_slot = fd_rng_ulong( rng );
3339 0 : fd_hash_generate( &self->last_slot_hash, alloc_mem, rng );
3340 0 : self->observed_stake = fd_rng_ulong( rng );
3341 0 : self->shred_version = fd_rng_ushort( rng );
3342 0 : return mem;
3343 0 : }
3344 :
3345 0 : void fd_crds_data_inner_generate( fd_crds_data_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
3346 0 : switch (discriminant) {
3347 0 : case 0: {
3348 0 : fd_gossip_contact_info_v1_generate( &self->contact_info_v1, alloc_mem, rng );
3349 0 : break;
3350 0 : }
3351 0 : case 1: {
3352 0 : fd_gossip_vote_generate( &self->vote, alloc_mem, rng );
3353 0 : break;
3354 0 : }
3355 0 : case 2: {
3356 0 : fd_gossip_lowest_slot_generate( &self->lowest_slot, alloc_mem, rng );
3357 0 : break;
3358 0 : }
3359 0 : case 3: {
3360 0 : fd_gossip_slot_hashes_generate( &self->snapshot_hashes, alloc_mem, rng );
3361 0 : break;
3362 0 : }
3363 0 : case 4: {
3364 0 : fd_gossip_slot_hashes_generate( &self->accounts_hashes, alloc_mem, rng );
3365 0 : break;
3366 0 : }
3367 0 : case 5: {
3368 0 : fd_gossip_epoch_slots_generate( &self->epoch_slots, alloc_mem, rng );
3369 0 : break;
3370 0 : }
3371 0 : case 6: {
3372 0 : fd_gossip_version_v1_generate( &self->version_v1, alloc_mem, rng );
3373 0 : break;
3374 0 : }
3375 0 : case 7: {
3376 0 : fd_gossip_version_v2_generate( &self->version_v2, alloc_mem, rng );
3377 0 : break;
3378 0 : }
3379 0 : case 8: {
3380 0 : fd_gossip_node_instance_generate( &self->node_instance, alloc_mem, rng );
3381 0 : break;
3382 0 : }
3383 0 : case 9: {
3384 0 : fd_gossip_duplicate_shred_generate( &self->duplicate_shred, alloc_mem, rng );
3385 0 : break;
3386 0 : }
3387 0 : case 10: {
3388 0 : fd_gossip_incremental_snapshot_hashes_generate( &self->incremental_snapshot_hashes, alloc_mem, rng );
3389 0 : break;
3390 0 : }
3391 0 : case 11: {
3392 0 : fd_gossip_contact_info_v2_generate( &self->contact_info_v2, alloc_mem, rng );
3393 0 : break;
3394 0 : }
3395 0 : case 12: {
3396 0 : fd_gossip_restart_last_voted_fork_slots_generate( &self->restart_last_voted_fork_slots, alloc_mem, rng );
3397 0 : break;
3398 0 : }
3399 0 : case 13: {
3400 0 : fd_gossip_restart_heaviest_fork_generate( &self->restart_heaviest_fork, alloc_mem, rng );
3401 0 : break;
3402 0 : }
3403 0 : }
3404 0 : }
3405 0 : void *fd_crds_data_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3406 0 : fd_crds_data_t *self = (fd_crds_data_t *) mem;
3407 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_crds_data_t);
3408 0 : fd_crds_data_new(mem);
3409 0 : self->discriminant = fd_rng_uint( rng ) % 14;
3410 0 : fd_crds_data_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
3411 0 : return mem;
3412 0 : }
3413 :
3414 0 : void *fd_crds_bloom_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3415 0 : fd_crds_bloom_t *self = (fd_crds_bloom_t *) mem;
3416 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_crds_bloom_t);
3417 0 : fd_crds_bloom_new(mem);
3418 0 : self->keys_len = fd_rng_ulong( rng ) % 8;
3419 0 : if( self->keys_len ) {
3420 0 : self->keys = (ulong *) *alloc_mem;
3421 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong)*self->keys_len;
3422 0 : LLVMFuzzerMutate( (uchar *) self->keys, sizeof(ulong)*self->keys_len, sizeof(ulong)*self->keys_len );
3423 0 : } else {
3424 0 : self->keys = NULL;
3425 0 : }
3426 0 : {
3427 0 : self->has_bits = fd_rng_uchar( rng ) % 2;
3428 0 : if( self->has_bits ) {
3429 0 : self->bits_bitvec_len = fd_rng_ulong( rng ) % 8;
3430 0 : if( self->bits_bitvec_len ) {
3431 0 : self->bits_bitvec = (ulong *) *alloc_mem;
3432 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong)*self->bits_bitvec_len;
3433 0 : LLVMFuzzerMutate( (uchar *) self->bits_bitvec, sizeof(ulong)*self->bits_bitvec_len, sizeof(ulong)*self->bits_bitvec_len );
3434 0 : } else {
3435 0 : self->bits_bitvec = NULL;
3436 0 : }
3437 0 : self->bits_len = self->bits_bitvec_len;
3438 0 : } else {
3439 0 : self->bits_len = 0UL;
3440 0 : }
3441 0 : }
3442 0 : self->num_bits_set = fd_rng_ulong( rng );
3443 0 : return mem;
3444 0 : }
3445 :
3446 0 : void *fd_crds_filter_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3447 0 : fd_crds_filter_t *self = (fd_crds_filter_t *) mem;
3448 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_crds_filter_t);
3449 0 : fd_crds_filter_new(mem);
3450 0 : fd_crds_bloom_generate( &self->filter, alloc_mem, rng );
3451 0 : self->mask = fd_rng_ulong( rng );
3452 0 : self->mask_bits = fd_rng_uint( rng );
3453 0 : return mem;
3454 0 : }
3455 :
3456 0 : void *fd_crds_value_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3457 0 : fd_crds_value_t *self = (fd_crds_value_t *) mem;
3458 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_crds_value_t);
3459 0 : fd_crds_value_new(mem);
3460 0 : fd_signature_generate( &self->signature, alloc_mem, rng );
3461 0 : fd_crds_data_generate( &self->data, alloc_mem, rng );
3462 0 : return mem;
3463 0 : }
3464 :
3465 0 : void *fd_gossip_pull_req_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3466 0 : fd_gossip_pull_req_t *self = (fd_gossip_pull_req_t *) mem;
3467 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_pull_req_t);
3468 0 : fd_gossip_pull_req_new(mem);
3469 0 : fd_crds_filter_generate( &self->filter, alloc_mem, rng );
3470 0 : fd_crds_value_generate( &self->value, alloc_mem, rng );
3471 0 : return mem;
3472 0 : }
3473 :
3474 0 : void *fd_gossip_pull_resp_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3475 0 : fd_gossip_pull_resp_t *self = (fd_gossip_pull_resp_t *) mem;
3476 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_pull_resp_t);
3477 0 : fd_gossip_pull_resp_new(mem);
3478 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
3479 0 : self->crds_len = fd_rng_ulong( rng ) % 8;
3480 0 : if( self->crds_len ) {
3481 0 : self->crds = (fd_crds_value_t *) *alloc_mem;
3482 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_crds_value_t)*self->crds_len;
3483 0 : for( ulong i=0; i < self->crds_len; i++ ) {
3484 0 : fd_crds_value_new( self->crds + i );
3485 0 : fd_crds_value_generate( self->crds + i, alloc_mem, rng );
3486 0 : }
3487 0 : } else {
3488 0 : self->crds = NULL;
3489 0 : }
3490 0 : return mem;
3491 0 : }
3492 :
3493 0 : void *fd_gossip_push_msg_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3494 0 : fd_gossip_push_msg_t *self = (fd_gossip_push_msg_t *) mem;
3495 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_push_msg_t);
3496 0 : fd_gossip_push_msg_new(mem);
3497 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
3498 0 : self->crds_len = fd_rng_ulong( rng ) % 8;
3499 0 : if( self->crds_len ) {
3500 0 : self->crds = (fd_crds_value_t *) *alloc_mem;
3501 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_crds_value_t)*self->crds_len;
3502 0 : for( ulong i=0; i < self->crds_len; i++ ) {
3503 0 : fd_crds_value_new( self->crds + i );
3504 0 : fd_crds_value_generate( self->crds + i, alloc_mem, rng );
3505 0 : }
3506 0 : } else {
3507 0 : self->crds = NULL;
3508 0 : }
3509 0 : return mem;
3510 0 : }
3511 :
3512 0 : void *fd_gossip_prune_msg_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3513 0 : fd_gossip_prune_msg_t *self = (fd_gossip_prune_msg_t *) mem;
3514 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_prune_msg_t);
3515 0 : fd_gossip_prune_msg_new(mem);
3516 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
3517 0 : fd_gossip_prune_data_generate( &self->data, alloc_mem, rng );
3518 0 : return mem;
3519 0 : }
3520 :
3521 0 : void fd_gossip_msg_inner_generate( fd_gossip_msg_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
3522 0 : switch (discriminant) {
3523 0 : case 0: {
3524 0 : fd_gossip_pull_req_generate( &self->pull_req, alloc_mem, rng );
3525 0 : break;
3526 0 : }
3527 0 : case 1: {
3528 0 : fd_gossip_pull_resp_generate( &self->pull_resp, alloc_mem, rng );
3529 0 : break;
3530 0 : }
3531 0 : case 2: {
3532 0 : fd_gossip_push_msg_generate( &self->push_msg, alloc_mem, rng );
3533 0 : break;
3534 0 : }
3535 0 : case 3: {
3536 0 : fd_gossip_prune_msg_generate( &self->prune_msg, alloc_mem, rng );
3537 0 : break;
3538 0 : }
3539 0 : case 4: {
3540 0 : fd_gossip_ping_generate( &self->ping, alloc_mem, rng );
3541 0 : break;
3542 0 : }
3543 0 : case 5: {
3544 0 : fd_gossip_ping_generate( &self->pong, alloc_mem, rng );
3545 0 : break;
3546 0 : }
3547 0 : }
3548 0 : }
3549 0 : void *fd_gossip_msg_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3550 0 : fd_gossip_msg_t *self = (fd_gossip_msg_t *) mem;
3551 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_msg_t);
3552 0 : fd_gossip_msg_new(mem);
3553 0 : self->discriminant = fd_rng_uint( rng ) % 6;
3554 0 : while( self->discriminant == 0 || self->discriminant == 1 || self->discriminant == 2 ) { self->discriminant = fd_rng_uint( rng ) % 6; }
3555 0 : fd_gossip_msg_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
3556 0 : return mem;
3557 0 : }
3558 :
3559 0 : void *fd_addrlut_create_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3560 0 : fd_addrlut_create_t *self = (fd_addrlut_create_t *) mem;
3561 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_addrlut_create_t);
3562 0 : fd_addrlut_create_new(mem);
3563 0 : self->recent_slot = fd_rng_ulong( rng );
3564 0 : self->bump_seed = fd_rng_uchar( rng );
3565 0 : return mem;
3566 0 : }
3567 :
3568 0 : void *fd_addrlut_extend_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3569 0 : fd_addrlut_extend_t *self = (fd_addrlut_extend_t *) mem;
3570 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_addrlut_extend_t);
3571 0 : fd_addrlut_extend_new(mem);
3572 0 : self->new_addrs_len = fd_rng_ulong( rng ) % 8;
3573 0 : if( self->new_addrs_len ) {
3574 0 : self->new_addrs = (fd_pubkey_t *) *alloc_mem;
3575 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t)*self->new_addrs_len;
3576 0 : for( ulong i=0; i < self->new_addrs_len; i++ ) {
3577 0 : fd_pubkey_new( self->new_addrs + i );
3578 0 : fd_pubkey_generate( self->new_addrs + i, alloc_mem, rng );
3579 0 : }
3580 0 : } else {
3581 0 : self->new_addrs = NULL;
3582 0 : }
3583 0 : return mem;
3584 0 : }
3585 :
3586 0 : void fd_addrlut_instruction_inner_generate( fd_addrlut_instruction_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
3587 0 : switch (discriminant) {
3588 0 : case 0: {
3589 0 : fd_addrlut_create_generate( &self->create_lut, alloc_mem, rng );
3590 0 : break;
3591 0 : }
3592 0 : case 2: {
3593 0 : fd_addrlut_extend_generate( &self->extend_lut, alloc_mem, rng );
3594 0 : break;
3595 0 : }
3596 0 : }
3597 0 : }
3598 0 : void *fd_addrlut_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3599 0 : fd_addrlut_instruction_t *self = (fd_addrlut_instruction_t *) mem;
3600 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_addrlut_instruction_t);
3601 0 : fd_addrlut_instruction_new(mem);
3602 0 : self->discriminant = fd_rng_uint( rng ) % 5;
3603 0 : fd_addrlut_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
3604 0 : return mem;
3605 0 : }
3606 :
3607 0 : void *fd_repair_request_header_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3608 0 : fd_repair_request_header_t *self = (fd_repair_request_header_t *) mem;
3609 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_request_header_t);
3610 0 : fd_repair_request_header_new(mem);
3611 0 : fd_signature_generate( &self->signature, alloc_mem, rng );
3612 0 : fd_pubkey_generate( &self->sender, alloc_mem, rng );
3613 0 : fd_pubkey_generate( &self->recipient, alloc_mem, rng );
3614 0 : self->timestamp = fd_rng_ulong( rng );
3615 0 : self->nonce = fd_rng_uint( rng );
3616 0 : return mem;
3617 0 : }
3618 :
3619 0 : void *fd_repair_window_index_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3620 0 : fd_repair_window_index_t *self = (fd_repair_window_index_t *) mem;
3621 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_window_index_t);
3622 0 : fd_repair_window_index_new(mem);
3623 0 : fd_repair_request_header_generate( &self->header, alloc_mem, rng );
3624 0 : self->slot = fd_rng_ulong( rng );
3625 0 : self->shred_index = fd_rng_ulong( rng );
3626 0 : return mem;
3627 0 : }
3628 :
3629 0 : void *fd_repair_highest_window_index_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3630 0 : fd_repair_highest_window_index_t *self = (fd_repair_highest_window_index_t *) mem;
3631 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_highest_window_index_t);
3632 0 : fd_repair_highest_window_index_new(mem);
3633 0 : fd_repair_request_header_generate( &self->header, alloc_mem, rng );
3634 0 : self->slot = fd_rng_ulong( rng );
3635 0 : self->shred_index = fd_rng_ulong( rng );
3636 0 : return mem;
3637 0 : }
3638 :
3639 0 : void *fd_repair_orphan_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3640 0 : fd_repair_orphan_t *self = (fd_repair_orphan_t *) mem;
3641 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_orphan_t);
3642 0 : fd_repair_orphan_new(mem);
3643 0 : fd_repair_request_header_generate( &self->header, alloc_mem, rng );
3644 0 : self->slot = fd_rng_ulong( rng );
3645 0 : return mem;
3646 0 : }
3647 :
3648 0 : void *fd_repair_ancestor_hashes_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3649 0 : fd_repair_ancestor_hashes_t *self = (fd_repair_ancestor_hashes_t *) mem;
3650 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_ancestor_hashes_t);
3651 0 : fd_repair_ancestor_hashes_new(mem);
3652 0 : fd_repair_request_header_generate( &self->header, alloc_mem, rng );
3653 0 : self->slot = fd_rng_ulong( rng );
3654 0 : return mem;
3655 0 : }
3656 :
3657 0 : void fd_repair_protocol_inner_generate( fd_repair_protocol_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
3658 0 : switch (discriminant) {
3659 0 : case 7: {
3660 0 : fd_gossip_ping_generate( &self->pong, alloc_mem, rng );
3661 0 : break;
3662 0 : }
3663 0 : case 8: {
3664 0 : fd_repair_window_index_generate( &self->window_index, alloc_mem, rng );
3665 0 : break;
3666 0 : }
3667 0 : case 9: {
3668 0 : fd_repair_highest_window_index_generate( &self->highest_window_index, alloc_mem, rng );
3669 0 : break;
3670 0 : }
3671 0 : case 10: {
3672 0 : fd_repair_orphan_generate( &self->orphan, alloc_mem, rng );
3673 0 : break;
3674 0 : }
3675 0 : case 11: {
3676 0 : fd_repair_ancestor_hashes_generate( &self->ancestor_hashes, alloc_mem, rng );
3677 0 : break;
3678 0 : }
3679 0 : }
3680 0 : }
3681 0 : void *fd_repair_protocol_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3682 0 : fd_repair_protocol_t *self = (fd_repair_protocol_t *) mem;
3683 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_protocol_t);
3684 0 : fd_repair_protocol_new(mem);
3685 0 : self->discriminant = fd_rng_uint( rng ) % 12;
3686 0 : fd_repair_protocol_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
3687 0 : return mem;
3688 0 : }
3689 :
3690 0 : void fd_repair_response_inner_generate( fd_repair_response_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
3691 0 : switch (discriminant) {
3692 0 : case 0: {
3693 0 : fd_gossip_ping_generate( &self->ping, alloc_mem, rng );
3694 0 : break;
3695 0 : }
3696 0 : }
3697 0 : }
3698 0 : void *fd_repair_response_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3699 0 : fd_repair_response_t *self = (fd_repair_response_t *) mem;
3700 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_response_t);
3701 0 : fd_repair_response_new(mem);
3702 0 : self->discriminant = fd_rng_uint( rng ) % 1;
3703 0 : fd_repair_response_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
3704 0 : return mem;
3705 0 : }
3706 :
3707 0 : void fd_instr_error_enum_inner_generate( fd_instr_error_enum_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
3708 0 : switch (discriminant) {
3709 0 : case 25: {
3710 0 : self->custom = fd_rng_uint( rng );
3711 0 : break;
3712 0 : }
3713 0 : case 44: {
3714 0 : ulong slen = fd_rng_ulong( rng ) % 256;
3715 0 : char *buffer = (char *) *alloc_mem;
3716 0 : *alloc_mem = (uchar *) *alloc_mem + slen;
3717 0 : self->borsh_io_error = buffer;
3718 0 : LLVMFuzzerMutate( (uchar *)self->borsh_io_error, slen, slen );
3719 0 : self->borsh_io_error[slen] = '\0';
3720 0 : break;
3721 0 : }
3722 0 : }
3723 0 : }
3724 0 : void *fd_instr_error_enum_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3725 0 : fd_instr_error_enum_t *self = (fd_instr_error_enum_t *) mem;
3726 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_instr_error_enum_t);
3727 0 : fd_instr_error_enum_new(mem);
3728 0 : self->discriminant = fd_rng_uint( rng ) % 54;
3729 0 : fd_instr_error_enum_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
3730 0 : return mem;
3731 0 : }
3732 :
3733 0 : void *fd_txn_instr_error_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3734 0 : fd_txn_instr_error_t *self = (fd_txn_instr_error_t *) mem;
3735 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_txn_instr_error_t);
3736 0 : fd_txn_instr_error_new(mem);
3737 0 : self->instr_idx = fd_rng_uchar( rng );
3738 0 : fd_instr_error_enum_generate( &self->error, alloc_mem, rng );
3739 0 : return mem;
3740 0 : }
3741 :
3742 0 : void fd_txn_error_enum_inner_generate( fd_txn_error_enum_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
3743 0 : switch (discriminant) {
3744 0 : case 8: {
3745 0 : fd_txn_instr_error_generate( &self->instruction_error, alloc_mem, rng );
3746 0 : break;
3747 0 : }
3748 0 : case 30: {
3749 0 : self->duplicate_instruction = fd_rng_uchar( rng );
3750 0 : break;
3751 0 : }
3752 0 : case 31: {
3753 0 : self->insufficient_funds_for_rent = fd_rng_uchar( rng );
3754 0 : break;
3755 0 : }
3756 0 : case 35: {
3757 0 : self->program_execution_temporarily_restricted = fd_rng_uchar( rng );
3758 0 : break;
3759 0 : }
3760 0 : }
3761 0 : }
3762 0 : void *fd_txn_error_enum_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3763 0 : fd_txn_error_enum_t *self = (fd_txn_error_enum_t *) mem;
3764 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_txn_error_enum_t);
3765 0 : fd_txn_error_enum_new(mem);
3766 0 : self->discriminant = fd_rng_uint( rng ) % 37;
3767 0 : fd_txn_error_enum_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
3768 0 : return mem;
3769 0 : }
3770 :
3771 0 : void fd_txn_result_inner_generate( fd_txn_result_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
3772 0 : switch (discriminant) {
3773 0 : case 1: {
3774 0 : fd_txn_error_enum_generate( &self->error, alloc_mem, rng );
3775 0 : break;
3776 0 : }
3777 0 : }
3778 0 : }
3779 0 : void *fd_txn_result_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3780 0 : fd_txn_result_t *self = (fd_txn_result_t *) mem;
3781 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_txn_result_t);
3782 0 : fd_txn_result_new(mem);
3783 0 : self->discriminant = fd_rng_uint( rng ) % 2;
3784 0 : fd_txn_result_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
3785 0 : return mem;
3786 0 : }
3787 :
3788 0 : void *fd_cache_status_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3789 0 : fd_cache_status_t *self = (fd_cache_status_t *) mem;
3790 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_cache_status_t);
3791 0 : fd_cache_status_new(mem);
3792 0 : LLVMFuzzerMutate( self->key_slice, 20, 20 );
3793 0 : fd_txn_result_generate( &self->result, alloc_mem, rng );
3794 0 : return mem;
3795 0 : }
3796 :
3797 0 : void *fd_status_value_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3798 0 : fd_status_value_t *self = (fd_status_value_t *) mem;
3799 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_status_value_t);
3800 0 : fd_status_value_new(mem);
3801 0 : self->txn_idx = fd_rng_ulong( rng );
3802 0 : self->statuses_len = fd_rng_ulong( rng ) % 8;
3803 0 : if( self->statuses_len ) {
3804 0 : self->statuses = (fd_cache_status_t *) *alloc_mem;
3805 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_cache_status_t)*self->statuses_len;
3806 0 : for( ulong i=0; i < self->statuses_len; i++ ) {
3807 0 : fd_cache_status_new( self->statuses + i );
3808 0 : fd_cache_status_generate( self->statuses + i, alloc_mem, rng );
3809 0 : }
3810 0 : } else {
3811 0 : self->statuses = NULL;
3812 0 : }
3813 0 : return mem;
3814 0 : }
3815 :
3816 0 : void *fd_status_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3817 0 : fd_status_pair_t *self = (fd_status_pair_t *) mem;
3818 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_status_pair_t);
3819 0 : fd_status_pair_new(mem);
3820 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
3821 0 : fd_status_value_generate( &self->value, alloc_mem, rng );
3822 0 : return mem;
3823 0 : }
3824 :
3825 0 : void *fd_slot_delta_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3826 0 : fd_slot_delta_t *self = (fd_slot_delta_t *) mem;
3827 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_delta_t);
3828 0 : fd_slot_delta_new(mem);
3829 0 : self->slot = fd_rng_ulong( rng );
3830 0 : self->is_root = fd_rng_uchar( rng );
3831 0 : self->slot_delta_vec_len = fd_rng_ulong( rng ) % 8;
3832 0 : if( self->slot_delta_vec_len ) {
3833 0 : self->slot_delta_vec = (fd_status_pair_t *) *alloc_mem;
3834 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_status_pair_t)*self->slot_delta_vec_len;
3835 0 : for( ulong i=0; i < self->slot_delta_vec_len; i++ ) {
3836 0 : fd_status_pair_new( self->slot_delta_vec + i );
3837 0 : fd_status_pair_generate( self->slot_delta_vec + i, alloc_mem, rng );
3838 0 : }
3839 0 : } else {
3840 0 : self->slot_delta_vec = NULL;
3841 0 : }
3842 0 : return mem;
3843 0 : }
3844 :
3845 0 : void *fd_bank_slot_deltas_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3846 0 : fd_bank_slot_deltas_t *self = (fd_bank_slot_deltas_t *) mem;
3847 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bank_slot_deltas_t);
3848 0 : fd_bank_slot_deltas_new(mem);
3849 0 : self->slot_deltas_len = fd_rng_ulong( rng ) % 8;
3850 0 : if( self->slot_deltas_len ) {
3851 0 : self->slot_deltas = (fd_slot_delta_t *) *alloc_mem;
3852 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_delta_t)*self->slot_deltas_len;
3853 0 : for( ulong i=0; i < self->slot_deltas_len; i++ ) {
3854 0 : fd_slot_delta_new( self->slot_deltas + i );
3855 0 : fd_slot_delta_generate( self->slot_deltas + i, alloc_mem, rng );
3856 0 : }
3857 0 : } else {
3858 0 : self->slot_deltas = NULL;
3859 0 : }
3860 0 : return mem;
3861 0 : }
3862 :
3863 0 : void *fd_pubkey_rewardinfo_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3864 0 : fd_pubkey_rewardinfo_pair_t *self = (fd_pubkey_rewardinfo_pair_t *) mem;
3865 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_rewardinfo_pair_t);
3866 0 : fd_pubkey_rewardinfo_pair_new(mem);
3867 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
3868 0 : fd_reward_info_generate( &self->reward_info, alloc_mem, rng );
3869 0 : return mem;
3870 0 : }
3871 :
3872 0 : void *fd_optional_account_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3873 0 : fd_optional_account_t *self = (fd_optional_account_t *) mem;
3874 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_optional_account_t);
3875 0 : fd_optional_account_new(mem);
3876 0 : {
3877 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
3878 0 : if( !is_null ) {
3879 0 : self->account = (fd_solana_account_t *) *alloc_mem;
3880 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_solana_account_t);
3881 0 : fd_solana_account_new( self->account );
3882 0 : fd_solana_account_generate( self->account, alloc_mem, rng );
3883 0 : }
3884 0 : else {
3885 0 : self->account = NULL;
3886 0 : }
3887 0 : }
3888 0 : return mem;
3889 0 : }
3890 :
3891 0 : void *fd_calculated_stake_points_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3892 0 : fd_calculated_stake_points_t *self = (fd_calculated_stake_points_t *) mem;
3893 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_calculated_stake_points_t);
3894 0 : fd_calculated_stake_points_new(mem);
3895 0 : self->points = fd_rng_uint128( rng );
3896 0 : self->new_credits_observed = fd_rng_ulong( rng );
3897 0 : self->force_credits_update_with_skipped_reward = fd_rng_uchar( rng );
3898 0 : return mem;
3899 0 : }
3900 :
3901 0 : void *fd_calculated_stake_rewards_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3902 0 : fd_calculated_stake_rewards_t *self = (fd_calculated_stake_rewards_t *) mem;
3903 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_calculated_stake_rewards_t);
3904 0 : fd_calculated_stake_rewards_new(mem);
3905 0 : self->staker_rewards = fd_rng_ulong( rng );
3906 0 : self->voter_rewards = fd_rng_ulong( rng );
3907 0 : self->new_credits_observed = fd_rng_ulong( rng );
3908 0 : return mem;
3909 0 : }
3910 :
3911 0 : void *fd_duplicate_slot_proof_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3912 0 : fd_duplicate_slot_proof_t *self = (fd_duplicate_slot_proof_t *) mem;
3913 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_duplicate_slot_proof_t);
3914 0 : fd_duplicate_slot_proof_new(mem);
3915 0 : self->shred1_len = fd_rng_ulong( rng ) % 8;
3916 0 : if( self->shred1_len ) {
3917 0 : self->shred1 = (uchar *) *alloc_mem;
3918 0 : *alloc_mem = (uchar *) *alloc_mem + self->shred1_len;
3919 0 : for( ulong i=0; i < self->shred1_len; ++i) { self->shred1[i] = fd_rng_uchar( rng ) % 0x80; }
3920 0 : } else {
3921 0 : self->shred1 = NULL;
3922 0 : }
3923 0 : self->shred2_len = fd_rng_ulong( rng ) % 8;
3924 0 : if( self->shred2_len ) {
3925 0 : self->shred2 = (uchar *) *alloc_mem;
3926 0 : *alloc_mem = (uchar *) *alloc_mem + self->shred2_len;
3927 0 : for( ulong i=0; i < self->shred2_len; ++i) { self->shred2[i] = fd_rng_uchar( rng ) % 0x80; }
3928 0 : } else {
3929 0 : self->shred2 = NULL;
3930 0 : }
3931 0 : return mem;
3932 0 : }
3933 :
3934 0 : void *fd_epoch_info_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3935 0 : fd_epoch_info_pair_t *self = (fd_epoch_info_pair_t *) mem;
3936 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_epoch_info_pair_t);
3937 0 : fd_epoch_info_pair_new(mem);
3938 0 : fd_pubkey_generate( &self->account, alloc_mem, rng );
3939 0 : fd_stake_generate( &self->stake, alloc_mem, rng );
3940 0 : return mem;
3941 0 : }
3942 :
3943 0 : void *fd_vote_info_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3944 0 : fd_vote_info_pair_t *self = (fd_vote_info_pair_t *) mem;
3945 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_info_pair_t);
3946 0 : fd_vote_info_pair_new(mem);
3947 0 : fd_pubkey_generate( &self->account, alloc_mem, rng );
3948 0 : fd_vote_state_versioned_generate( &self->state, alloc_mem, rng );
3949 0 : return mem;
3950 0 : }
3951 :
3952 0 : void *fd_epoch_info_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3953 0 : fd_epoch_info_t *self = (fd_epoch_info_t *) mem;
3954 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_epoch_info_t);
3955 0 : fd_epoch_info_new(mem);
3956 0 : self->stake_infos_len = fd_rng_ulong( rng ) % 8;
3957 0 : if( self->stake_infos_len ) {
3958 0 : self->stake_infos = (fd_epoch_info_pair_t *) *alloc_mem;
3959 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_epoch_info_pair_t)*self->stake_infos_len;
3960 0 : for( ulong i=0; i < self->stake_infos_len; i++ ) {
3961 0 : fd_epoch_info_pair_new( self->stake_infos + i );
3962 0 : fd_epoch_info_pair_generate( self->stake_infos + i, alloc_mem, rng );
3963 0 : }
3964 0 : } else {
3965 0 : self->stake_infos = NULL;
3966 0 : }
3967 0 : ulong vote_states_len = fd_rng_ulong( rng ) % 8;
3968 0 : self->vote_states_pool = fd_vote_info_pair_t_map_join_new( alloc_mem, vote_states_len );
3969 0 : self->vote_states_root = NULL;
3970 0 : for( ulong i=0; i < vote_states_len; i++ ) {
3971 0 : fd_vote_info_pair_t_mapnode_t * node = fd_vote_info_pair_t_map_acquire( self->vote_states_pool );
3972 0 : fd_vote_info_pair_generate( &node->elem, alloc_mem, rng );
3973 0 : fd_vote_info_pair_t_map_insert( self->vote_states_pool, &self->vote_states_root, node );
3974 0 : }
3975 0 : self->stake_infos_new_keys_start_idx = fd_rng_ulong( rng );
3976 0 : return mem;
3977 0 : }
3978 :
3979 0 : void *fd_usage_cost_details_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
3980 0 : fd_usage_cost_details_t *self = (fd_usage_cost_details_t *) mem;
3981 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_usage_cost_details_t);
3982 0 : fd_usage_cost_details_new(mem);
3983 0 : self->signature_cost = fd_rng_ulong( rng );
3984 0 : self->write_lock_cost = fd_rng_ulong( rng );
3985 0 : self->data_bytes_cost = fd_rng_ulong( rng );
3986 0 : self->programs_execution_cost = fd_rng_ulong( rng );
3987 0 : self->loaded_accounts_data_size_cost = fd_rng_ulong( rng );
3988 0 : self->allocated_accounts_data_size = fd_rng_ulong( rng );
3989 0 : return mem;
3990 0 : }
3991 :
3992 0 : void fd_transaction_cost_inner_generate( fd_transaction_cost_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
3993 0 : switch (discriminant) {
3994 0 : case 1: {
3995 0 : fd_usage_cost_details_generate( &self->transaction, alloc_mem, rng );
3996 0 : break;
3997 0 : }
3998 0 : }
3999 0 : }
4000 0 : void *fd_transaction_cost_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
4001 0 : fd_transaction_cost_t *self = (fd_transaction_cost_t *) mem;
4002 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_transaction_cost_t);
4003 0 : fd_transaction_cost_new(mem);
4004 0 : self->discriminant = fd_rng_uint( rng ) % 2;
4005 0 : fd_transaction_cost_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
4006 0 : return mem;
4007 0 : }
4008 :
4009 0 : void *fd_account_costs_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
4010 0 : fd_account_costs_pair_t *self = (fd_account_costs_pair_t *) mem;
4011 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_account_costs_pair_t);
4012 0 : fd_account_costs_pair_new(mem);
4013 0 : fd_pubkey_generate( &self->key, alloc_mem, rng );
4014 0 : self->cost = fd_rng_ulong( rng );
4015 0 : return mem;
4016 0 : }
4017 :
4018 0 : void *fd_account_costs_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
4019 0 : fd_account_costs_t *self = (fd_account_costs_t *) mem;
4020 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_account_costs_t);
4021 0 : fd_account_costs_new(mem);
4022 0 : ulong account_costs_len = fd_rng_ulong( rng ) % 8;
4023 0 : self->account_costs_pool = fd_account_costs_pair_t_map_join_new( alloc_mem, fd_ulong_max( account_costs_len, 4096 ) );
4024 0 : self->account_costs_root = NULL;
4025 0 : for( ulong i=0; i < account_costs_len; i++ ) {
4026 0 : fd_account_costs_pair_t_mapnode_t * node = fd_account_costs_pair_t_map_acquire( self->account_costs_pool );
4027 0 : fd_account_costs_pair_generate( &node->elem, alloc_mem, rng );
4028 0 : fd_account_costs_pair_t_map_insert( self->account_costs_pool, &self->account_costs_root, node );
4029 0 : }
4030 0 : return mem;
4031 0 : }
4032 :
4033 0 : void *fd_cost_tracker_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
4034 0 : fd_cost_tracker_t *self = (fd_cost_tracker_t *) mem;
4035 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_cost_tracker_t);
4036 0 : fd_cost_tracker_new(mem);
4037 0 : self->account_cost_limit = fd_rng_ulong( rng );
4038 0 : self->block_cost_limit = fd_rng_ulong( rng );
4039 0 : self->vote_cost_limit = fd_rng_ulong( rng );
4040 0 : fd_account_costs_generate( &self->cost_by_writable_accounts, alloc_mem, rng );
4041 0 : self->block_cost = fd_rng_ulong( rng );
4042 0 : self->vote_cost = fd_rng_ulong( rng );
4043 0 : self->transaction_count = fd_rng_ulong( rng );
4044 0 : self->allocated_accounts_data_size = fd_rng_ulong( rng );
4045 0 : self->transaction_signature_count = fd_rng_ulong( rng );
4046 0 : self->secp256k1_instruction_signature_count = fd_rng_ulong( rng );
4047 0 : self->ed25519_instruction_signature_count = fd_rng_ulong( rng );
4048 0 : self->secp256r1_instruction_signature_count = fd_rng_ulong( rng );
4049 0 : return mem;
4050 0 : }
4051 :
4052 0 : void *fd_rent_paying_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
4053 0 : fd_rent_paying_t *self = (fd_rent_paying_t *) mem;
4054 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_rent_paying_t);
4055 0 : fd_rent_paying_new(mem);
4056 0 : self->lamports = fd_rng_ulong( rng );
4057 0 : self->data_size = fd_rng_ulong( rng );
4058 0 : return mem;
4059 0 : }
4060 :
4061 0 : void fd_rent_state_inner_generate( fd_rent_state_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
4062 0 : switch (discriminant) {
4063 0 : case 1: {
4064 0 : fd_rent_paying_generate( &self->rent_paying, alloc_mem, rng );
4065 0 : break;
4066 0 : }
4067 0 : }
4068 0 : }
4069 0 : void *fd_rent_state_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
4070 0 : fd_rent_state_t *self = (fd_rent_state_t *) mem;
4071 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_rent_state_t);
4072 0 : fd_rent_state_new(mem);
4073 0 : self->discriminant = fd_rng_uint( rng ) % 3;
4074 0 : fd_rent_state_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
4075 0 : return mem;
4076 0 : }
4077 :
4078 : #endif // HEADER_FUZZ_FD_RUNTIME_TYPES
|
