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_hash_generate(void *mem, void **alloc_mem, fd_rng_t * rng) {
14 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_hash_t);
15 0 : fd_hash_new(mem);
16 0 : LLVMFuzzerMutate( (uchar *) mem, sizeof(fd_hash_t), sizeof(fd_hash_t));
17 0 : return mem;
18 0 : }
19 :
20 0 : void *fd_pubkey_generate(void *mem, void **alloc_mem, fd_rng_t * rng) {
21 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t);
22 0 : fd_pubkey_new(mem);
23 0 : LLVMFuzzerMutate( (uchar *) mem, sizeof(fd_pubkey_t), sizeof(fd_pubkey_t));
24 0 : return mem;
25 0 : }
26 :
27 0 : void *fd_signature_generate(void *mem, void **alloc_mem, fd_rng_t * rng) {
28 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_signature_t);
29 0 : fd_signature_new(mem);
30 0 : LLVMFuzzerMutate( (uchar *) mem, sizeof(fd_signature_t), sizeof(fd_signature_t));
31 0 : return mem;
32 0 : }
33 :
34 0 : void *fd_feature_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
35 0 : fd_feature_t *self = (fd_feature_t *) mem;
36 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_feature_t);
37 0 : fd_feature_new(mem);
38 0 : {
39 0 : self->has_activated_at = fd_rng_uchar( rng ) % 2;
40 0 : if( self->has_activated_at ) {
41 0 : LLVMFuzzerMutate( (uchar *)&(self->activated_at), sizeof(ulong), sizeof(ulong) );
42 0 : }
43 0 : }
44 0 : return mem;
45 0 : }
46 :
47 0 : void *fd_fee_calculator_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
48 0 : fd_fee_calculator_t *self = (fd_fee_calculator_t *) mem;
49 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_fee_calculator_t);
50 0 : fd_fee_calculator_new(mem);
51 0 : self->lamports_per_signature = fd_rng_ulong( rng );
52 0 : return mem;
53 0 : }
54 :
55 0 : void *fd_fee_rate_governor_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
56 0 : fd_fee_rate_governor_t *self = (fd_fee_rate_governor_t *) mem;
57 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_fee_rate_governor_t);
58 0 : fd_fee_rate_governor_new(mem);
59 0 : self->target_lamports_per_signature = fd_rng_ulong( rng );
60 0 : self->target_signatures_per_slot = fd_rng_ulong( rng );
61 0 : self->min_lamports_per_signature = fd_rng_ulong( rng );
62 0 : self->max_lamports_per_signature = fd_rng_ulong( rng );
63 0 : self->burn_percent = fd_rng_uchar( rng );
64 0 : return mem;
65 0 : }
66 :
67 0 : void *fd_slot_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
68 0 : fd_slot_pair_t *self = (fd_slot_pair_t *) mem;
69 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_pair_t);
70 0 : fd_slot_pair_new(mem);
71 0 : self->slot = fd_rng_ulong( rng );
72 0 : self->val = fd_rng_ulong( rng );
73 0 : return mem;
74 0 : }
75 :
76 0 : void *fd_hard_forks_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
77 0 : fd_hard_forks_t *self = (fd_hard_forks_t *) mem;
78 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_hard_forks_t);
79 0 : fd_hard_forks_new(mem);
80 0 : self->hard_forks_len = fd_rng_ulong( rng ) % 8;
81 0 : if( self->hard_forks_len ) {
82 0 : self->hard_forks = (fd_slot_pair_t *) *alloc_mem;
83 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_pair_t)*self->hard_forks_len;
84 0 : for( ulong i=0; i < self->hard_forks_len; i++ ) {
85 0 : fd_slot_pair_new( self->hard_forks + i );
86 0 : fd_slot_pair_generate( self->hard_forks + i, alloc_mem, rng );
87 0 : }
88 0 : } else {
89 0 : self->hard_forks = NULL;
90 0 : }
91 0 : return mem;
92 0 : }
93 :
94 0 : void *fd_inflation_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
95 0 : fd_inflation_t *self = (fd_inflation_t *) mem;
96 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_inflation_t);
97 0 : fd_inflation_new(mem);
98 0 : self->initial = fd_rng_double_o( rng );
99 0 : self->terminal = fd_rng_double_o( rng );
100 0 : self->taper = fd_rng_double_o( rng );
101 0 : self->foundation = fd_rng_double_o( rng );
102 0 : self->foundation_term = fd_rng_double_o( rng );
103 0 : self->unused = fd_rng_double_o( rng );
104 0 : return mem;
105 0 : }
106 :
107 0 : void *fd_rent_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
108 0 : fd_rent_t *self = (fd_rent_t *) mem;
109 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_rent_t);
110 0 : fd_rent_new(mem);
111 0 : self->lamports_per_uint8_year = fd_rng_ulong( rng );
112 0 : self->exemption_threshold = fd_rng_double_o( rng );
113 0 : self->burn_percent = fd_rng_uchar( rng );
114 0 : return mem;
115 0 : }
116 :
117 0 : void *fd_epoch_schedule_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
118 0 : fd_epoch_schedule_t *self = (fd_epoch_schedule_t *) mem;
119 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_epoch_schedule_t);
120 0 : fd_epoch_schedule_new(mem);
121 0 : self->slots_per_epoch = fd_rng_ulong( rng );
122 0 : self->leader_schedule_slot_offset = fd_rng_ulong( rng );
123 0 : self->warmup = fd_rng_uchar( rng );
124 0 : self->first_normal_epoch = fd_rng_ulong( rng );
125 0 : self->first_normal_slot = fd_rng_ulong( rng );
126 0 : return mem;
127 0 : }
128 :
129 0 : void *fd_rent_collector_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
130 0 : fd_rent_collector_t *self = (fd_rent_collector_t *) mem;
131 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_rent_collector_t);
132 0 : fd_rent_collector_new(mem);
133 0 : self->epoch = fd_rng_ulong( rng );
134 0 : fd_epoch_schedule_generate( &self->epoch_schedule, alloc_mem, rng );
135 0 : self->slots_per_year = fd_rng_double_o( rng );
136 0 : fd_rent_generate( &self->rent, alloc_mem, rng );
137 0 : return mem;
138 0 : }
139 :
140 0 : void *fd_stake_history_entry_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
141 0 : fd_stake_history_entry_t *self = (fd_stake_history_entry_t *) mem;
142 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_history_entry_t);
143 0 : fd_stake_history_entry_new(mem);
144 0 : self->effective = fd_rng_ulong( rng );
145 0 : self->activating = fd_rng_ulong( rng );
146 0 : self->deactivating = fd_rng_ulong( rng );
147 0 : return mem;
148 0 : }
149 :
150 0 : void *fd_epoch_stake_history_entry_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
151 0 : fd_epoch_stake_history_entry_pair_t *self = (fd_epoch_stake_history_entry_pair_t *) mem;
152 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_epoch_stake_history_entry_pair_t);
153 0 : fd_epoch_stake_history_entry_pair_new(mem);
154 0 : self->epoch = fd_rng_ulong( rng );
155 0 : fd_stake_history_entry_generate( &self->entry, alloc_mem, rng );
156 0 : return mem;
157 0 : }
158 :
159 0 : void *fd_stake_history_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
160 0 : fd_stake_history_t *self = (fd_stake_history_t *) mem;
161 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_history_t);
162 0 : fd_stake_history_new(mem);
163 0 : self->fd_stake_history_len = fd_rng_ulong( rng ) % 8;
164 0 : self->fd_stake_history_size = 512;
165 0 : self->fd_stake_history_offset = 0;
166 0 : for( ulong i=0; i<self->fd_stake_history_len; i++ ) {
167 0 : fd_epoch_stake_history_entry_pair_generate( self->fd_stake_history + i, alloc_mem, rng );
168 0 : }
169 0 : return mem;
170 0 : }
171 :
172 0 : void *fd_solana_account_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
173 0 : fd_solana_account_t *self = (fd_solana_account_t *) mem;
174 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_solana_account_t);
175 0 : fd_solana_account_new(mem);
176 0 : self->lamports = fd_rng_ulong( rng );
177 0 : self->data_len = fd_rng_ulong( rng ) % 8;
178 0 : if( self->data_len ) {
179 0 : self->data = (uchar *) *alloc_mem;
180 0 : *alloc_mem = (uchar *) *alloc_mem + self->data_len;
181 0 : for( ulong i=0; i < self->data_len; ++i) { self->data[i] = fd_rng_uchar( rng ) % 0x80; }
182 0 : } else {
183 0 : self->data = NULL;
184 0 : }
185 0 : fd_pubkey_generate( &self->owner, alloc_mem, rng );
186 0 : self->executable = fd_rng_uchar( rng );
187 0 : self->rent_epoch = fd_rng_ulong( rng );
188 0 : return mem;
189 0 : }
190 :
191 0 : void *fd_solana_account_stored_meta_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
192 0 : fd_solana_account_stored_meta_t *self = (fd_solana_account_stored_meta_t *) mem;
193 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_solana_account_stored_meta_t);
194 0 : fd_solana_account_stored_meta_new(mem);
195 0 : self->write_version_obsolete = fd_rng_ulong( rng );
196 0 : self->data_len = fd_rng_ulong( rng );
197 0 : LLVMFuzzerMutate( &self->pubkey[0], sizeof(self->pubkey), sizeof(self->pubkey) );
198 0 : return mem;
199 0 : }
200 :
201 0 : void *fd_solana_account_meta_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
202 0 : fd_solana_account_meta_t *self = (fd_solana_account_meta_t *) mem;
203 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_solana_account_meta_t);
204 0 : fd_solana_account_meta_new(mem);
205 0 : self->lamports = fd_rng_ulong( rng );
206 0 : self->rent_epoch = fd_rng_ulong( rng );
207 0 : LLVMFuzzerMutate( &self->owner[0], sizeof(self->owner), sizeof(self->owner) );
208 0 : self->executable = fd_rng_uchar( rng );
209 0 : LLVMFuzzerMutate( self->padding, 3, 3 );
210 0 : return mem;
211 0 : }
212 :
213 0 : void *fd_solana_account_hdr_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
214 0 : fd_solana_account_hdr_t *self = (fd_solana_account_hdr_t *) mem;
215 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_solana_account_hdr_t);
216 0 : fd_solana_account_hdr_new(mem);
217 0 : fd_solana_account_stored_meta_generate( &self->meta, alloc_mem, rng );
218 0 : fd_solana_account_meta_generate( &self->info, alloc_mem, rng );
219 0 : LLVMFuzzerMutate( self->padding, 4, 4 );
220 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
221 0 : return mem;
222 0 : }
223 :
224 0 : void *fd_delegation_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
225 0 : fd_delegation_t *self = (fd_delegation_t *) mem;
226 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_delegation_t);
227 0 : fd_delegation_new(mem);
228 0 : fd_pubkey_generate( &self->voter_pubkey, alloc_mem, rng );
229 0 : self->stake = fd_rng_ulong( rng );
230 0 : self->activation_epoch = fd_rng_ulong( rng );
231 0 : self->deactivation_epoch = fd_rng_ulong( rng );
232 0 : self->warmup_cooldown_rate = fd_rng_double_o( rng );
233 0 : return mem;
234 0 : }
235 :
236 0 : void *fd_stake_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
237 0 : fd_stake_t *self = (fd_stake_t *) mem;
238 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_t);
239 0 : fd_stake_new(mem);
240 0 : fd_delegation_generate( &self->delegation, alloc_mem, rng );
241 0 : self->credits_observed = fd_rng_ulong( rng );
242 0 : return mem;
243 0 : }
244 :
245 0 : void *fd_reward_type_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
246 0 : fd_reward_type_t *self = (fd_reward_type_t *) mem;
247 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_reward_type_t);
248 0 : fd_reward_type_new(mem);
249 0 : self->discriminant = fd_rng_uint( rng ) % 4;
250 0 : return mem;
251 0 : }
252 :
253 0 : void *fd_reward_info_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
254 0 : fd_reward_info_t *self = (fd_reward_info_t *) mem;
255 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_reward_info_t);
256 0 : fd_reward_info_new(mem);
257 0 : fd_reward_type_generate( &self->reward_type, alloc_mem, rng );
258 0 : self->lamports = fd_rng_ulong( rng );
259 0 : self->post_balance = fd_rng_ulong( rng );
260 0 : self->commission = fd_rng_ulong( rng );
261 0 : return mem;
262 0 : }
263 :
264 0 : void *fd_rust_duration_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
265 0 : fd_rust_duration_t *self = (fd_rust_duration_t *) mem;
266 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_rust_duration_t);
267 0 : fd_rust_duration_new(mem);
268 0 : self->seconds = fd_rng_ulong( rng );
269 0 : self->nanoseconds = fd_rng_uint( rng );
270 0 : return mem;
271 0 : }
272 :
273 0 : void *fd_poh_config_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
274 0 : fd_poh_config_t *self = (fd_poh_config_t *) mem;
275 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_poh_config_t);
276 0 : fd_poh_config_new(mem);
277 0 : fd_rust_duration_generate( &self->target_tick_duration, alloc_mem, rng );
278 0 : {
279 0 : self->has_target_tick_count = fd_rng_uchar( rng ) % 2;
280 0 : if( self->has_target_tick_count ) {
281 0 : LLVMFuzzerMutate( (uchar *)&(self->target_tick_count), sizeof(ulong), sizeof(ulong) );
282 0 : }
283 0 : }
284 0 : {
285 0 : self->has_hashes_per_tick = fd_rng_uchar( rng ) % 2;
286 0 : if( self->has_hashes_per_tick ) {
287 0 : LLVMFuzzerMutate( (uchar *)&(self->hashes_per_tick), sizeof(ulong), sizeof(ulong) );
288 0 : }
289 0 : }
290 0 : return mem;
291 0 : }
292 :
293 0 : void *fd_string_pubkey_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
294 0 : fd_string_pubkey_pair_t *self = (fd_string_pubkey_pair_t *) mem;
295 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_string_pubkey_pair_t);
296 0 : fd_string_pubkey_pair_new(mem);
297 0 : self->string_len = fd_rng_ulong( rng ) % 8;
298 0 : if( self->string_len ) {
299 0 : self->string = (uchar *) *alloc_mem;
300 0 : *alloc_mem = (uchar *) *alloc_mem + self->string_len;
301 0 : for( ulong i=0; i < self->string_len; ++i) { self->string[i] = fd_rng_uchar( rng ) % 0x80; }
302 0 : } else {
303 0 : self->string = NULL;
304 0 : }
305 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
306 0 : return mem;
307 0 : }
308 :
309 0 : void *fd_pubkey_account_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
310 0 : fd_pubkey_account_pair_t *self = (fd_pubkey_account_pair_t *) mem;
311 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_account_pair_t);
312 0 : fd_pubkey_account_pair_new(mem);
313 0 : fd_pubkey_generate( &self->key, alloc_mem, rng );
314 0 : fd_solana_account_generate( &self->account, alloc_mem, rng );
315 0 : return mem;
316 0 : }
317 :
318 0 : void *fd_genesis_solana_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
319 0 : fd_genesis_solana_t *self = (fd_genesis_solana_t *) mem;
320 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_genesis_solana_t);
321 0 : fd_genesis_solana_new(mem);
322 0 : self->creation_time = fd_rng_ulong( rng );
323 0 : self->accounts_len = fd_rng_ulong( rng ) % 8;
324 0 : if( self->accounts_len ) {
325 0 : self->accounts = (fd_pubkey_account_pair_t *) *alloc_mem;
326 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_account_pair_t)*self->accounts_len;
327 0 : for( ulong i=0; i < self->accounts_len; i++ ) {
328 0 : fd_pubkey_account_pair_new( self->accounts + i );
329 0 : fd_pubkey_account_pair_generate( self->accounts + i, alloc_mem, rng );
330 0 : }
331 0 : } else {
332 0 : self->accounts = NULL;
333 0 : }
334 0 : self->native_instruction_processors_len = fd_rng_ulong( rng ) % 8;
335 0 : if( self->native_instruction_processors_len ) {
336 0 : self->native_instruction_processors = (fd_string_pubkey_pair_t *) *alloc_mem;
337 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_string_pubkey_pair_t)*self->native_instruction_processors_len;
338 0 : for( ulong i=0; i < self->native_instruction_processors_len; i++ ) {
339 0 : fd_string_pubkey_pair_new( self->native_instruction_processors + i );
340 0 : fd_string_pubkey_pair_generate( self->native_instruction_processors + i, alloc_mem, rng );
341 0 : }
342 0 : } else {
343 0 : self->native_instruction_processors = NULL;
344 0 : }
345 0 : self->rewards_pools_len = fd_rng_ulong( rng ) % 8;
346 0 : if( self->rewards_pools_len ) {
347 0 : self->rewards_pools = (fd_pubkey_account_pair_t *) *alloc_mem;
348 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_account_pair_t)*self->rewards_pools_len;
349 0 : for( ulong i=0; i < self->rewards_pools_len; i++ ) {
350 0 : fd_pubkey_account_pair_new( self->rewards_pools + i );
351 0 : fd_pubkey_account_pair_generate( self->rewards_pools + i, alloc_mem, rng );
352 0 : }
353 0 : } else {
354 0 : self->rewards_pools = NULL;
355 0 : }
356 0 : self->ticks_per_slot = fd_rng_ulong( rng );
357 0 : self->unused = fd_rng_ulong( rng );
358 0 : fd_poh_config_generate( &self->poh_config, alloc_mem, rng );
359 0 : self->__backwards_compat_with_v0_23 = fd_rng_ulong( rng );
360 0 : fd_fee_rate_governor_generate( &self->fee_rate_governor, alloc_mem, rng );
361 0 : fd_rent_generate( &self->rent, alloc_mem, rng );
362 0 : fd_inflation_generate( &self->inflation, alloc_mem, rng );
363 0 : fd_epoch_schedule_generate( &self->epoch_schedule, alloc_mem, rng );
364 0 : self->cluster_type = fd_rng_uint( rng );
365 0 : return mem;
366 0 : }
367 :
368 0 : void *fd_sol_sysvar_clock_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
369 0 : fd_sol_sysvar_clock_t *self = (fd_sol_sysvar_clock_t *) mem;
370 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_sol_sysvar_clock_t);
371 0 : fd_sol_sysvar_clock_new(mem);
372 0 : self->slot = fd_rng_ulong( rng );
373 0 : self->epoch_start_timestamp = fd_rng_long( rng );
374 0 : self->epoch = fd_rng_ulong( rng );
375 0 : self->leader_schedule_epoch = fd_rng_ulong( rng );
376 0 : self->unix_timestamp = fd_rng_long( rng );
377 0 : return mem;
378 0 : }
379 :
380 0 : void *fd_sol_sysvar_last_restart_slot_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
381 0 : fd_sol_sysvar_last_restart_slot_t *self = (fd_sol_sysvar_last_restart_slot_t *) mem;
382 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_sol_sysvar_last_restart_slot_t);
383 0 : fd_sol_sysvar_last_restart_slot_new(mem);
384 0 : self->slot = fd_rng_ulong( rng );
385 0 : return mem;
386 0 : }
387 :
388 0 : void *fd_vote_lockout_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
389 0 : fd_vote_lockout_t *self = (fd_vote_lockout_t *) mem;
390 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_lockout_t);
391 0 : fd_vote_lockout_new(mem);
392 0 : self->slot = fd_rng_ulong( rng );
393 0 : self->confirmation_count = fd_rng_uint( rng );
394 0 : return mem;
395 0 : }
396 :
397 0 : void *fd_lockout_offset_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
398 0 : fd_lockout_offset_t *self = (fd_lockout_offset_t *) mem;
399 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_lockout_offset_t);
400 0 : fd_lockout_offset_new(mem);
401 0 : self->offset = fd_rng_ulong( rng );
402 0 : self->confirmation_count = fd_rng_uchar( rng );
403 0 : return mem;
404 0 : }
405 :
406 0 : void *fd_vote_authorized_voter_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
407 0 : fd_vote_authorized_voter_t *self = (fd_vote_authorized_voter_t *) mem;
408 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_authorized_voter_t);
409 0 : fd_vote_authorized_voter_new(mem);
410 0 : self->epoch = fd_rng_ulong( rng );
411 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
412 0 : self->parent = fd_rng_ulong( rng );
413 0 : self->left = fd_rng_ulong( rng );
414 0 : self->right = fd_rng_ulong( rng );
415 0 : self->prio = fd_rng_ulong( rng );
416 0 : return mem;
417 0 : }
418 :
419 0 : void *fd_vote_prior_voter_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
420 0 : fd_vote_prior_voter_t *self = (fd_vote_prior_voter_t *) mem;
421 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_prior_voter_t);
422 0 : fd_vote_prior_voter_new(mem);
423 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
424 0 : self->epoch_start = fd_rng_ulong( rng );
425 0 : self->epoch_end = fd_rng_ulong( rng );
426 0 : return mem;
427 0 : }
428 :
429 0 : void *fd_vote_prior_voter_0_23_5_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
430 0 : fd_vote_prior_voter_0_23_5_t *self = (fd_vote_prior_voter_0_23_5_t *) mem;
431 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_prior_voter_0_23_5_t);
432 0 : fd_vote_prior_voter_0_23_5_new(mem);
433 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
434 0 : self->epoch_start = fd_rng_ulong( rng );
435 0 : self->epoch_end = fd_rng_ulong( rng );
436 0 : self->slot = fd_rng_ulong( rng );
437 0 : return mem;
438 0 : }
439 :
440 0 : void *fd_vote_epoch_credits_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
441 0 : fd_vote_epoch_credits_t *self = (fd_vote_epoch_credits_t *) mem;
442 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_epoch_credits_t);
443 0 : fd_vote_epoch_credits_new(mem);
444 0 : self->epoch = fd_rng_ulong( rng );
445 0 : self->credits = fd_rng_ulong( rng );
446 0 : self->prev_credits = fd_rng_ulong( rng );
447 0 : return mem;
448 0 : }
449 :
450 0 : void *fd_vote_block_timestamp_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
451 0 : fd_vote_block_timestamp_t *self = (fd_vote_block_timestamp_t *) mem;
452 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_block_timestamp_t);
453 0 : fd_vote_block_timestamp_new(mem);
454 0 : self->slot = fd_rng_ulong( rng );
455 0 : self->timestamp = fd_rng_long( rng );
456 0 : return mem;
457 0 : }
458 :
459 0 : void *fd_vote_prior_voters_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
460 0 : fd_vote_prior_voters_t *self = (fd_vote_prior_voters_t *) mem;
461 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_prior_voters_t);
462 0 : fd_vote_prior_voters_new(mem);
463 0 : for( ulong i=0; i<32; i++ ) {
464 0 : fd_vote_prior_voter_generate( self->buf + i, alloc_mem, rng );
465 0 : }
466 0 : self->idx = fd_rng_ulong( rng );
467 0 : self->is_empty = fd_rng_uchar( rng );
468 0 : return mem;
469 0 : }
470 :
471 0 : void *fd_vote_prior_voters_0_23_5_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
472 0 : fd_vote_prior_voters_0_23_5_t *self = (fd_vote_prior_voters_0_23_5_t *) mem;
473 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_prior_voters_0_23_5_t);
474 0 : fd_vote_prior_voters_0_23_5_new(mem);
475 0 : for( ulong i=0; i<32; i++ ) {
476 0 : fd_vote_prior_voter_0_23_5_generate( self->buf + i, alloc_mem, rng );
477 0 : }
478 0 : self->idx = fd_rng_ulong( rng );
479 0 : return mem;
480 0 : }
481 :
482 0 : void *fd_landed_vote_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
483 0 : fd_landed_vote_t *self = (fd_landed_vote_t *) mem;
484 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_landed_vote_t);
485 0 : fd_landed_vote_new(mem);
486 0 : self->latency = fd_rng_uchar( rng );
487 0 : fd_vote_lockout_generate( &self->lockout, alloc_mem, rng );
488 0 : return mem;
489 0 : }
490 :
491 0 : void *fd_vote_state_0_23_5_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
492 0 : fd_vote_state_0_23_5_t *self = (fd_vote_state_0_23_5_t *) mem;
493 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_state_0_23_5_t);
494 0 : fd_vote_state_0_23_5_new(mem);
495 0 : fd_pubkey_generate( &self->node_pubkey, alloc_mem, rng );
496 0 : fd_pubkey_generate( &self->authorized_voter, alloc_mem, rng );
497 0 : self->authorized_voter_epoch = fd_rng_ulong( rng );
498 0 : fd_vote_prior_voters_0_23_5_generate( &self->prior_voters, alloc_mem, rng );
499 0 : fd_pubkey_generate( &self->authorized_withdrawer, alloc_mem, rng );
500 0 : self->commission = fd_rng_uchar( rng );
501 0 : ulong votes_len = fd_rng_ulong( rng ) % 8;
502 0 : ulong votes_max = fd_ulong_max( votes_len, 32 );
503 0 : self->votes = deq_fd_vote_lockout_t_join_new( alloc_mem, votes_max );
504 0 : for( ulong i=0; i < votes_len; i++ ) {
505 0 : fd_vote_lockout_t * elem = deq_fd_vote_lockout_t_push_tail_nocopy( self->votes );
506 0 : fd_vote_lockout_generate( elem, alloc_mem, rng );
507 0 : }
508 0 : {
509 0 : self->has_root_slot = fd_rng_uchar( rng ) % 2;
510 0 : if( self->has_root_slot ) {
511 0 : LLVMFuzzerMutate( (uchar *)&(self->root_slot), sizeof(ulong), sizeof(ulong) );
512 0 : }
513 0 : }
514 0 : ulong epoch_credits_len = fd_rng_ulong( rng ) % 8;
515 0 : ulong epoch_credits_max = fd_ulong_max( epoch_credits_len, 64 );
516 0 : self->epoch_credits = deq_fd_vote_epoch_credits_t_join_new( alloc_mem, epoch_credits_max );
517 0 : for( ulong i=0; i < epoch_credits_len; i++ ) {
518 0 : fd_vote_epoch_credits_t * elem = deq_fd_vote_epoch_credits_t_push_tail_nocopy( self->epoch_credits );
519 0 : fd_vote_epoch_credits_generate( elem, alloc_mem, rng );
520 0 : }
521 0 : fd_vote_block_timestamp_generate( &self->last_timestamp, alloc_mem, rng );
522 0 : return mem;
523 0 : }
524 :
525 0 : void *fd_vote_authorized_voters_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
526 0 : fd_vote_authorized_voters_t *self = (fd_vote_authorized_voters_t *) mem;
527 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_authorized_voters_t);
528 0 : fd_vote_authorized_voters_new(mem);
529 0 : ulong fd_vote_authorized_voters_treap_len = fd_rng_ulong( rng ) % 8;
530 0 : ulong fd_vote_authorized_voters_treap_max = fd_ulong_max( fd_vote_authorized_voters_treap_len, FD_VOTE_AUTHORIZED_VOTERS_MIN );
531 0 : self->pool = fd_vote_authorized_voters_pool_join_new( alloc_mem, fd_vote_authorized_voters_treap_max );
532 0 : self->treap = fd_vote_authorized_voters_treap_join_new( alloc_mem, fd_vote_authorized_voters_treap_max );
533 0 : for( ulong i=0; i < fd_vote_authorized_voters_treap_len; i++ ) {
534 0 : fd_vote_authorized_voter_t * ele = fd_vote_authorized_voters_pool_ele_acquire( self->pool );
535 0 : fd_vote_authorized_voter_generate( ele, alloc_mem, rng );
536 0 : fd_vote_authorized_voter_t * repeated_entry = fd_vote_authorized_voters_treap_ele_query( self->treap, ele->epoch, self->pool );
537 0 : if( repeated_entry ) {
538 0 : fd_vote_authorized_voters_treap_ele_remove( self->treap, repeated_entry, self->pool ); // Remove the element before inserting it back to avoid duplication
539 0 : fd_vote_authorized_voters_pool_ele_release( self->pool, repeated_entry );
540 0 : }
541 0 : fd_vote_authorized_voters_treap_ele_insert( self->treap, ele, self->pool ); /* this cannot fail */
542 0 : }
543 0 : return mem;
544 0 : }
545 :
546 0 : void *fd_vote_state_1_14_11_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
547 0 : fd_vote_state_1_14_11_t *self = (fd_vote_state_1_14_11_t *) mem;
548 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_state_1_14_11_t);
549 0 : fd_vote_state_1_14_11_new(mem);
550 0 : fd_pubkey_generate( &self->node_pubkey, alloc_mem, rng );
551 0 : fd_pubkey_generate( &self->authorized_withdrawer, alloc_mem, rng );
552 0 : self->commission = fd_rng_uchar( rng );
553 0 : ulong votes_len = fd_rng_ulong( rng ) % 8;
554 0 : ulong votes_max = fd_ulong_max( votes_len, 32 );
555 0 : self->votes = deq_fd_vote_lockout_t_join_new( alloc_mem, votes_max );
556 0 : for( ulong i=0; i < votes_len; i++ ) {
557 0 : fd_vote_lockout_t * elem = deq_fd_vote_lockout_t_push_tail_nocopy( self->votes );
558 0 : fd_vote_lockout_generate( elem, alloc_mem, rng );
559 0 : }
560 0 : {
561 0 : self->has_root_slot = fd_rng_uchar( rng ) % 2;
562 0 : if( self->has_root_slot ) {
563 0 : LLVMFuzzerMutate( (uchar *)&(self->root_slot), sizeof(ulong), sizeof(ulong) );
564 0 : }
565 0 : }
566 0 : fd_vote_authorized_voters_generate( &self->authorized_voters, alloc_mem, rng );
567 0 : fd_vote_prior_voters_generate( &self->prior_voters, alloc_mem, rng );
568 0 : ulong epoch_credits_len = fd_rng_ulong( rng ) % 8;
569 0 : ulong epoch_credits_max = fd_ulong_max( epoch_credits_len, 64 );
570 0 : self->epoch_credits = deq_fd_vote_epoch_credits_t_join_new( alloc_mem, epoch_credits_max );
571 0 : for( ulong i=0; i < epoch_credits_len; i++ ) {
572 0 : fd_vote_epoch_credits_t * elem = deq_fd_vote_epoch_credits_t_push_tail_nocopy( self->epoch_credits );
573 0 : fd_vote_epoch_credits_generate( elem, alloc_mem, rng );
574 0 : }
575 0 : fd_vote_block_timestamp_generate( &self->last_timestamp, alloc_mem, rng );
576 0 : return mem;
577 0 : }
578 :
579 0 : void *fd_vote_state_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
580 0 : fd_vote_state_t *self = (fd_vote_state_t *) mem;
581 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_state_t);
582 0 : fd_vote_state_new(mem);
583 0 : fd_pubkey_generate( &self->node_pubkey, alloc_mem, rng );
584 0 : fd_pubkey_generate( &self->authorized_withdrawer, alloc_mem, rng );
585 0 : self->commission = fd_rng_uchar( rng );
586 0 : ulong votes_len = fd_rng_ulong( rng ) % 8;
587 0 : ulong votes_max = fd_ulong_max( votes_len, 32 );
588 0 : self->votes = deq_fd_landed_vote_t_join_new( alloc_mem, votes_max );
589 0 : for( ulong i=0; i < votes_len; i++ ) {
590 0 : fd_landed_vote_t * elem = deq_fd_landed_vote_t_push_tail_nocopy( self->votes );
591 0 : fd_landed_vote_generate( elem, alloc_mem, rng );
592 0 : }
593 0 : {
594 0 : self->has_root_slot = fd_rng_uchar( rng ) % 2;
595 0 : if( self->has_root_slot ) {
596 0 : LLVMFuzzerMutate( (uchar *)&(self->root_slot), sizeof(ulong), sizeof(ulong) );
597 0 : }
598 0 : }
599 0 : fd_vote_authorized_voters_generate( &self->authorized_voters, alloc_mem, rng );
600 0 : fd_vote_prior_voters_generate( &self->prior_voters, alloc_mem, rng );
601 0 : ulong epoch_credits_len = fd_rng_ulong( rng ) % 8;
602 0 : ulong epoch_credits_max = fd_ulong_max( epoch_credits_len, 64 );
603 0 : self->epoch_credits = deq_fd_vote_epoch_credits_t_join_new( alloc_mem, epoch_credits_max );
604 0 : for( ulong i=0; i < epoch_credits_len; i++ ) {
605 0 : fd_vote_epoch_credits_t * elem = deq_fd_vote_epoch_credits_t_push_tail_nocopy( self->epoch_credits );
606 0 : fd_vote_epoch_credits_generate( elem, alloc_mem, rng );
607 0 : }
608 0 : fd_vote_block_timestamp_generate( &self->last_timestamp, alloc_mem, rng );
609 0 : return mem;
610 0 : }
611 :
612 0 : void fd_vote_state_versioned_inner_generate( fd_vote_state_versioned_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
613 0 : switch (discriminant) {
614 0 : case 0: {
615 0 : fd_vote_state_0_23_5_generate( &self->v0_23_5, alloc_mem, rng );
616 0 : break;
617 0 : }
618 0 : case 1: {
619 0 : fd_vote_state_1_14_11_generate( &self->v1_14_11, alloc_mem, rng );
620 0 : break;
621 0 : }
622 0 : case 2: {
623 0 : fd_vote_state_generate( &self->current, alloc_mem, rng );
624 0 : break;
625 0 : }
626 0 : }
627 0 : }
628 0 : void *fd_vote_state_versioned_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
629 0 : fd_vote_state_versioned_t *self = (fd_vote_state_versioned_t *) mem;
630 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_state_versioned_t);
631 0 : fd_vote_state_versioned_new(mem);
632 0 : self->discriminant = fd_rng_uint( rng ) % 3;
633 0 : fd_vote_state_versioned_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
634 0 : return mem;
635 0 : }
636 :
637 0 : void *fd_vote_state_update_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
638 0 : fd_vote_state_update_t *self = (fd_vote_state_update_t *) mem;
639 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_state_update_t);
640 0 : fd_vote_state_update_new(mem);
641 0 : ulong lockouts_len = fd_rng_ulong( rng ) % 8;
642 0 : ulong lockouts_max = fd_ulong_max( lockouts_len, 32 );
643 0 : self->lockouts = deq_fd_vote_lockout_t_join_new( alloc_mem, lockouts_max );
644 0 : for( ulong i=0; i < lockouts_len; i++ ) {
645 0 : fd_vote_lockout_t * elem = deq_fd_vote_lockout_t_push_tail_nocopy( self->lockouts );
646 0 : fd_vote_lockout_generate( elem, alloc_mem, rng );
647 0 : }
648 0 : {
649 0 : self->has_root = fd_rng_uchar( rng ) % 2;
650 0 : if( self->has_root ) {
651 0 : LLVMFuzzerMutate( (uchar *)&(self->root), sizeof(ulong), sizeof(ulong) );
652 0 : }
653 0 : }
654 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
655 0 : {
656 0 : self->has_timestamp = fd_rng_uchar( rng ) % 2;
657 0 : if( self->has_timestamp ) {
658 0 : LLVMFuzzerMutate( (uchar *)&(self->timestamp), sizeof(long), sizeof(long) );
659 0 : }
660 0 : }
661 0 : return mem;
662 0 : }
663 :
664 0 : void *fd_compact_vote_state_update_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
665 0 : fd_compact_vote_state_update_t *self = (fd_compact_vote_state_update_t *) mem;
666 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_compact_vote_state_update_t);
667 0 : fd_compact_vote_state_update_new(mem);
668 0 : self->root = fd_rng_ulong( rng );
669 0 : self->lockouts_len = fd_rng_ulong( rng ) % 8;
670 0 : if( self->lockouts_len ) {
671 0 : self->lockouts = (fd_lockout_offset_t *) *alloc_mem;
672 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_lockout_offset_t)*self->lockouts_len;
673 0 : for( ulong i=0; i < self->lockouts_len; i++ ) {
674 0 : fd_lockout_offset_new( self->lockouts + i );
675 0 : fd_lockout_offset_generate( self->lockouts + i, alloc_mem, rng );
676 0 : }
677 0 : } else {
678 0 : self->lockouts = NULL;
679 0 : }
680 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
681 0 : {
682 0 : self->has_timestamp = fd_rng_uchar( rng ) % 2;
683 0 : if( self->has_timestamp ) {
684 0 : LLVMFuzzerMutate( (uchar *)&(self->timestamp), sizeof(long), sizeof(long) );
685 0 : }
686 0 : }
687 0 : return mem;
688 0 : }
689 :
690 0 : void *fd_compact_vote_state_update_switch_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
691 0 : fd_compact_vote_state_update_switch_t *self = (fd_compact_vote_state_update_switch_t *) mem;
692 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_compact_vote_state_update_switch_t);
693 0 : fd_compact_vote_state_update_switch_new(mem);
694 0 : fd_compact_vote_state_update_generate( &self->compact_vote_state_update, alloc_mem, rng );
695 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
696 0 : return mem;
697 0 : }
698 :
699 0 : void *fd_compact_tower_sync_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
700 0 : fd_compact_tower_sync_t *self = (fd_compact_tower_sync_t *) mem;
701 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_compact_tower_sync_t);
702 0 : fd_compact_tower_sync_new(mem);
703 0 : self->root = fd_rng_ulong( rng );
704 0 : ulong lockout_offsets_len = fd_rng_ulong( rng ) % 8;
705 0 : ulong lockout_offsets_max = fd_ulong_max( lockout_offsets_len, 32 );
706 0 : self->lockout_offsets = deq_fd_lockout_offset_t_join_new( alloc_mem, lockout_offsets_max );
707 0 : for( ulong i=0; i < lockout_offsets_len; i++ ) {
708 0 : fd_lockout_offset_t * elem = deq_fd_lockout_offset_t_push_tail_nocopy( self->lockout_offsets );
709 0 : fd_lockout_offset_generate( elem, alloc_mem, rng );
710 0 : }
711 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
712 0 : {
713 0 : self->has_timestamp = fd_rng_uchar( rng ) % 2;
714 0 : if( self->has_timestamp ) {
715 0 : LLVMFuzzerMutate( (uchar *)&(self->timestamp), sizeof(long), sizeof(long) );
716 0 : }
717 0 : }
718 0 : fd_hash_generate( &self->block_id, alloc_mem, rng );
719 0 : return mem;
720 0 : }
721 :
722 :
723 0 : void *fd_tower_sync_switch_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
724 0 : fd_tower_sync_switch_t *self = (fd_tower_sync_switch_t *) mem;
725 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_tower_sync_switch_t);
726 0 : fd_tower_sync_switch_new(mem);
727 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
728 0 : return mem;
729 0 : }
730 :
731 0 : void *fd_slot_history_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
732 0 : fd_slot_history_t *self = (fd_slot_history_t *) mem;
733 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_history_t);
734 0 : fd_slot_history_new(mem);
735 0 : {
736 0 : self->has_bits = fd_rng_uchar( rng ) % 2;
737 0 : if( self->has_bits ) {
738 0 : self->bits_bitvec_len = fd_rng_ulong( rng ) % 8;
739 0 : if( self->bits_bitvec_len ) {
740 0 : self->bits_bitvec = (ulong *) *alloc_mem;
741 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong)*self->bits_bitvec_len;
742 0 : LLVMFuzzerMutate( (uchar *) self->bits_bitvec, sizeof(ulong)*self->bits_bitvec_len, sizeof(ulong)*self->bits_bitvec_len );
743 0 : } else {
744 0 : self->bits_bitvec = NULL;
745 0 : }
746 0 : self->bits_len = self->bits_bitvec_len;
747 0 : } else {
748 0 : self->bits_len = 0UL;
749 0 : }
750 0 : }
751 0 : self->next_slot = fd_rng_ulong( rng );
752 0 : return mem;
753 0 : }
754 :
755 0 : void *fd_slot_hash_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
756 0 : fd_slot_hash_t *self = (fd_slot_hash_t *) mem;
757 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_hash_t);
758 0 : fd_slot_hash_new(mem);
759 0 : self->slot = fd_rng_ulong( rng );
760 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
761 0 : return mem;
762 0 : }
763 :
764 0 : void *fd_slot_hashes_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
765 0 : fd_slot_hashes_t *self = (fd_slot_hashes_t *) mem;
766 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_hashes_t);
767 0 : fd_slot_hashes_new(mem);
768 0 : ulong hashes_len = fd_rng_ulong( rng ) % 8;
769 0 : ulong hashes_max = fd_ulong_max( hashes_len, 512 );
770 0 : self->hashes = deq_fd_slot_hash_t_join_new( alloc_mem, hashes_max );
771 0 : for( ulong i=0; i < hashes_len; i++ ) {
772 0 : fd_slot_hash_t * elem = deq_fd_slot_hash_t_push_tail_nocopy( self->hashes );
773 0 : fd_slot_hash_generate( elem, alloc_mem, rng );
774 0 : }
775 0 : return mem;
776 0 : }
777 :
778 0 : void *fd_block_block_hash_entry_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
779 0 : fd_block_block_hash_entry_t *self = (fd_block_block_hash_entry_t *) mem;
780 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_block_block_hash_entry_t);
781 0 : fd_block_block_hash_entry_new(mem);
782 0 : fd_hash_generate( &self->blockhash, alloc_mem, rng );
783 0 : fd_fee_calculator_generate( &self->fee_calculator, alloc_mem, rng );
784 0 : return mem;
785 0 : }
786 :
787 0 : void *fd_recent_block_hashes_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
788 0 : fd_recent_block_hashes_t *self = (fd_recent_block_hashes_t *) mem;
789 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_recent_block_hashes_t);
790 0 : fd_recent_block_hashes_new(mem);
791 0 : ulong hashes_len = fd_rng_ulong( rng ) % 8;
792 0 : ulong hashes_max = fd_ulong_max( hashes_len, 151 );
793 0 : self->hashes = deq_fd_block_block_hash_entry_t_join_new( alloc_mem, hashes_max );
794 0 : for( ulong i=0; i < hashes_len; i++ ) {
795 0 : fd_block_block_hash_entry_t * elem = deq_fd_block_block_hash_entry_t_push_tail_nocopy( self->hashes );
796 0 : fd_block_block_hash_entry_generate( elem, alloc_mem, rng );
797 0 : }
798 0 : return mem;
799 0 : }
800 :
801 0 : void *fd_slot_meta_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
802 0 : fd_slot_meta_t *self = (fd_slot_meta_t *) mem;
803 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_slot_meta_t);
804 0 : fd_slot_meta_new(mem);
805 0 : self->slot = fd_rng_ulong( rng );
806 0 : self->consumed = fd_rng_ulong( rng );
807 0 : self->received = fd_rng_ulong( rng );
808 0 : self->first_shred_timestamp = fd_rng_long( rng );
809 0 : self->last_index = fd_rng_ulong( rng );
810 0 : self->parent_slot = fd_rng_ulong( rng );
811 0 : self->next_slot_len = fd_rng_ulong( rng ) % 8;
812 0 : if( self->next_slot_len ) {
813 0 : self->next_slot = (ulong *) *alloc_mem;
814 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong)*self->next_slot_len;
815 0 : LLVMFuzzerMutate( (uchar *) self->next_slot, sizeof(ulong)*self->next_slot_len, sizeof(ulong)*self->next_slot_len );
816 0 : } else {
817 0 : self->next_slot = NULL;
818 0 : }
819 0 : self->is_connected = fd_rng_uchar( rng );
820 0 : self->entry_end_indexes_len = fd_rng_ulong( rng ) % 8;
821 0 : if( self->entry_end_indexes_len ) {
822 0 : self->entry_end_indexes = (uint *) *alloc_mem;
823 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(uint)*self->entry_end_indexes_len;
824 0 : LLVMFuzzerMutate( (uchar *) self->entry_end_indexes, sizeof(uint)*self->entry_end_indexes_len, sizeof(uint)*self->entry_end_indexes_len );
825 0 : } else {
826 0 : self->entry_end_indexes = NULL;
827 0 : }
828 0 : return mem;
829 0 : }
830 :
831 0 : void *fd_clock_timestamp_vote_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
832 0 : fd_clock_timestamp_vote_t *self = (fd_clock_timestamp_vote_t *) mem;
833 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_clock_timestamp_vote_t);
834 0 : fd_clock_timestamp_vote_new(mem);
835 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
836 0 : self->timestamp = fd_rng_long( rng );
837 0 : self->slot = fd_rng_ulong( rng );
838 0 : return mem;
839 0 : }
840 :
841 0 : void *fd_clock_timestamp_votes_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
842 0 : fd_clock_timestamp_votes_t *self = (fd_clock_timestamp_votes_t *) mem;
843 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_clock_timestamp_votes_t);
844 0 : fd_clock_timestamp_votes_new(mem);
845 0 : ulong votes_len = fd_rng_ulong( rng ) % 8;
846 0 : self->votes_pool = fd_clock_timestamp_vote_t_map_join_new( alloc_mem, fd_ulong_max( votes_len, 15000 ) );
847 0 : self->votes_root = NULL;
848 0 : for( ulong i=0; i < votes_len; i++ ) {
849 0 : fd_clock_timestamp_vote_t_mapnode_t * node = fd_clock_timestamp_vote_t_map_acquire( self->votes_pool );
850 0 : fd_clock_timestamp_vote_generate( &node->elem, alloc_mem, rng );
851 0 : fd_clock_timestamp_vote_t_map_insert( self->votes_pool, &self->votes_root, node );
852 0 : }
853 0 : return mem;
854 0 : }
855 :
856 0 : void *fd_sysvar_fees_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
857 0 : fd_sysvar_fees_t *self = (fd_sysvar_fees_t *) mem;
858 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_sysvar_fees_t);
859 0 : fd_sysvar_fees_new(mem);
860 0 : fd_fee_calculator_generate( &self->fee_calculator, alloc_mem, rng );
861 0 : return mem;
862 0 : }
863 :
864 0 : void *fd_sysvar_epoch_rewards_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
865 0 : fd_sysvar_epoch_rewards_t *self = (fd_sysvar_epoch_rewards_t *) mem;
866 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_sysvar_epoch_rewards_t);
867 0 : fd_sysvar_epoch_rewards_new(mem);
868 0 : self->distribution_starting_block_height = fd_rng_ulong( rng );
869 0 : self->num_partitions = fd_rng_ulong( rng );
870 0 : fd_hash_generate( &self->parent_blockhash, alloc_mem, rng );
871 0 : self->total_points = fd_rng_uint128( rng );
872 0 : self->total_rewards = fd_rng_ulong( rng );
873 0 : self->distributed_rewards = fd_rng_ulong( rng );
874 0 : self->active = fd_rng_uchar( rng );
875 0 : return mem;
876 0 : }
877 :
878 0 : void *fd_config_keys_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
879 0 : fd_config_keys_pair_t *self = (fd_config_keys_pair_t *) mem;
880 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_config_keys_pair_t);
881 0 : fd_config_keys_pair_new(mem);
882 0 : fd_pubkey_generate( &self->key, alloc_mem, rng );
883 0 : self->signer = fd_rng_uchar( rng );
884 0 : return mem;
885 0 : }
886 :
887 0 : void *fd_stake_config_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
888 0 : fd_stake_config_t *self = (fd_stake_config_t *) mem;
889 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_config_t);
890 0 : fd_stake_config_new(mem);
891 0 : self->config_keys_len = fd_rng_ulong( rng ) % 8;
892 0 : if( self->config_keys_len ) {
893 0 : self->config_keys = (fd_config_keys_pair_t *) *alloc_mem;
894 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_config_keys_pair_t)*self->config_keys_len;
895 0 : for( ulong i=0; i < self->config_keys_len; i++ ) {
896 0 : fd_config_keys_pair_new( self->config_keys + i );
897 0 : fd_config_keys_pair_generate( self->config_keys + i, alloc_mem, rng );
898 0 : }
899 0 : } else {
900 0 : self->config_keys = NULL;
901 0 : }
902 0 : self->warmup_cooldown_rate = fd_rng_double_o( rng );
903 0 : self->slash_penalty = fd_rng_uchar( rng );
904 0 : return mem;
905 0 : }
906 :
907 0 : void *fd_feature_entry_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
908 0 : fd_feature_entry_t *self = (fd_feature_entry_t *) mem;
909 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_feature_entry_t);
910 0 : fd_feature_entry_new(mem);
911 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
912 0 : self->description_len = fd_rng_ulong( rng ) % 8;
913 0 : if( self->description_len ) {
914 0 : self->description = (uchar *) *alloc_mem;
915 0 : *alloc_mem = (uchar *) *alloc_mem + self->description_len;
916 0 : for( ulong i=0; i < self->description_len; ++i) { self->description[i] = fd_rng_uchar( rng ) % 0x80; }
917 0 : } else {
918 0 : self->description = NULL;
919 0 : }
920 0 : self->since_slot = fd_rng_ulong( rng );
921 0 : return mem;
922 0 : }
923 :
924 0 : void *fd_cluster_type_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
925 0 : fd_cluster_type_t *self = (fd_cluster_type_t *) mem;
926 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_cluster_type_t);
927 0 : fd_cluster_type_new(mem);
928 0 : self->discriminant = fd_rng_uint( rng ) % 4;
929 0 : return mem;
930 0 : }
931 :
932 0 : void *fd_cluster_version_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
933 0 : fd_cluster_version_t *self = (fd_cluster_version_t *) mem;
934 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_cluster_version_t);
935 0 : fd_cluster_version_new(mem);
936 0 : self->major = fd_rng_uint( rng );
937 0 : self->minor = fd_rng_uint( rng );
938 0 : self->patch = fd_rng_uint( rng );
939 0 : return mem;
940 0 : }
941 :
942 0 : void *fd_stake_reward_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
943 0 : fd_stake_reward_t *self = (fd_stake_reward_t *) mem;
944 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_reward_t);
945 0 : fd_stake_reward_new(mem);
946 0 : self->prev = fd_rng_ulong( rng );
947 0 : self->next = fd_rng_ulong( rng );
948 0 : self->parent = fd_rng_ulong( rng );
949 0 : fd_pubkey_generate( &self->stake_pubkey, alloc_mem, rng );
950 0 : self->credits_observed = fd_rng_ulong( rng );
951 0 : self->lamports = fd_rng_ulong( rng );
952 0 : self->valid = fd_rng_uchar( rng );
953 0 : return mem;
954 0 : }
955 :
956 0 : void *fd_vote_reward_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
957 0 : fd_vote_reward_t *self = (fd_vote_reward_t *) mem;
958 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_reward_t);
959 0 : fd_vote_reward_new(mem);
960 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
961 0 : self->vote_rewards = fd_rng_ulong( rng );
962 0 : self->commission = fd_rng_uchar( rng );
963 0 : self->needs_store = fd_rng_uchar( rng );
964 0 : return mem;
965 0 : }
966 :
967 0 : void *fd_point_value_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
968 0 : fd_point_value_t *self = (fd_point_value_t *) mem;
969 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_point_value_t);
970 0 : fd_point_value_new(mem);
971 0 : self->rewards = fd_rng_ulong( rng );
972 0 : self->points = fd_rng_uint128( rng );
973 0 : return mem;
974 0 : }
975 :
976 0 : void *fd_partitioned_stake_rewards_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
977 0 : fd_partitioned_stake_rewards_t *self = (fd_partitioned_stake_rewards_t *) mem;
978 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_partitioned_stake_rewards_t);
979 0 : fd_partitioned_stake_rewards_new(mem);
980 0 : self->partitions_len = fd_rng_ulong( rng ) % 8;
981 0 : ulong total_count = 0UL;
982 0 : for( ulong i=0; i < 4096; i++ ) {
983 0 : self->partitions_lengths[i] = fd_rng_ulong( rng ) % 8;
984 0 : total_count += self->partitions_lengths[ i ];
985 0 : }
986 0 : self->pool = fd_partitioned_stake_rewards_pool_join_new( alloc_mem, total_count );
987 0 : self->partitions = fd_partitioned_stake_rewards_dlist_join_new( alloc_mem, self->partitions_len );
988 0 : for( ulong i=0; i < self->partitions_len; i++ ) {
989 0 : fd_partitioned_stake_rewards_dlist_new( &self->partitions[ i ] );
990 0 : for( ulong j=0; j < self->partitions_lengths[ i ]; j++ ) {
991 0 : fd_stake_reward_t * ele = fd_partitioned_stake_rewards_pool_ele_acquire( self->pool );
992 0 : fd_stake_reward_new( ele );
993 0 : fd_stake_reward_generate( ele, alloc_mem, rng );
994 0 : fd_partitioned_stake_rewards_dlist_ele_push_tail( &self->partitions[ i ], ele, self->pool );
995 0 : }
996 0 : }
997 0 : return mem;
998 0 : }
999 :
1000 0 : void *fd_stake_reward_calculation_partitioned_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1001 0 : fd_stake_reward_calculation_partitioned_t *self = (fd_stake_reward_calculation_partitioned_t *) mem;
1002 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_reward_calculation_partitioned_t);
1003 0 : fd_stake_reward_calculation_partitioned_new(mem);
1004 0 : fd_partitioned_stake_rewards_generate( &self->partitioned_stake_rewards, alloc_mem, rng );
1005 0 : self->total_stake_rewards_lamports = fd_rng_ulong( rng );
1006 0 : return mem;
1007 0 : }
1008 :
1009 0 : void *fd_stake_reward_calculation_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1010 0 : fd_stake_reward_calculation_t *self = (fd_stake_reward_calculation_t *) mem;
1011 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_reward_calculation_t);
1012 0 : fd_stake_reward_calculation_new(mem);
1013 0 : self->stake_rewards_len = fd_rng_ulong( rng ) % 8;
1014 0 : self->pool = fd_stake_reward_calculation_pool_join_new( alloc_mem, self->stake_rewards_len );
1015 0 : self->stake_rewards = fd_stake_reward_calculation_dlist_join_new( alloc_mem, self->stake_rewards_len );
1016 0 : fd_stake_reward_calculation_dlist_new( self->stake_rewards );
1017 0 : for( ulong i=0; i < self->stake_rewards_len; i++ ) {
1018 0 : fd_stake_reward_t * ele = fd_stake_reward_calculation_pool_ele_acquire( self->pool );
1019 0 : fd_stake_reward_new( ele );
1020 0 : fd_stake_reward_generate( ele, alloc_mem, rng );
1021 0 : fd_stake_reward_calculation_dlist_ele_push_tail( self->stake_rewards, ele, self->pool );
1022 0 : }
1023 0 : self->total_stake_rewards_lamports = fd_rng_ulong( rng );
1024 0 : return mem;
1025 0 : }
1026 :
1027 0 : void *fd_calculate_stake_vote_rewards_result_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1028 0 : fd_calculate_stake_vote_rewards_result_t *self = (fd_calculate_stake_vote_rewards_result_t *) mem;
1029 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_calculate_stake_vote_rewards_result_t);
1030 0 : fd_calculate_stake_vote_rewards_result_new(mem);
1031 0 : fd_stake_reward_calculation_generate( &self->stake_reward_calculation, alloc_mem, rng );
1032 0 : ulong vote_reward_map_len = fd_rng_ulong( rng ) % 8;
1033 0 : self->vote_reward_map_pool = fd_vote_reward_t_map_join_new( alloc_mem, fd_ulong_max( vote_reward_map_len, 15000 ) );
1034 0 : self->vote_reward_map_root = NULL;
1035 0 : for( ulong i=0; i < vote_reward_map_len; i++ ) {
1036 0 : fd_vote_reward_t_mapnode_t * node = fd_vote_reward_t_map_acquire( self->vote_reward_map_pool );
1037 0 : fd_vote_reward_generate( &node->elem, alloc_mem, rng );
1038 0 : fd_vote_reward_t_map_insert( self->vote_reward_map_pool, &self->vote_reward_map_root, node );
1039 0 : }
1040 0 : return mem;
1041 0 : }
1042 :
1043 0 : void *fd_calculate_validator_rewards_result_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1044 0 : fd_calculate_validator_rewards_result_t *self = (fd_calculate_validator_rewards_result_t *) mem;
1045 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_calculate_validator_rewards_result_t);
1046 0 : fd_calculate_validator_rewards_result_new(mem);
1047 0 : fd_calculate_stake_vote_rewards_result_generate( &self->calculate_stake_vote_rewards_result, alloc_mem, rng );
1048 0 : fd_point_value_generate( &self->point_value, alloc_mem, rng );
1049 0 : return mem;
1050 0 : }
1051 :
1052 0 : void *fd_partitioned_rewards_calculation_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1053 0 : fd_partitioned_rewards_calculation_t *self = (fd_partitioned_rewards_calculation_t *) mem;
1054 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_partitioned_rewards_calculation_t);
1055 0 : fd_partitioned_rewards_calculation_new(mem);
1056 0 : ulong vote_reward_map_len = fd_rng_ulong( rng ) % 8;
1057 0 : self->vote_reward_map_pool = fd_vote_reward_t_map_join_new( alloc_mem, fd_ulong_max( vote_reward_map_len, 15000 ) );
1058 0 : self->vote_reward_map_root = NULL;
1059 0 : for( ulong i=0; i < vote_reward_map_len; i++ ) {
1060 0 : fd_vote_reward_t_mapnode_t * node = fd_vote_reward_t_map_acquire( self->vote_reward_map_pool );
1061 0 : fd_vote_reward_generate( &node->elem, alloc_mem, rng );
1062 0 : fd_vote_reward_t_map_insert( self->vote_reward_map_pool, &self->vote_reward_map_root, node );
1063 0 : }
1064 0 : fd_stake_reward_calculation_partitioned_generate( &self->stake_rewards_by_partition, alloc_mem, rng );
1065 0 : self->old_vote_balance_and_staked = fd_rng_ulong( rng );
1066 0 : self->validator_rewards = fd_rng_ulong( rng );
1067 0 : self->validator_rate = fd_rng_double_o( rng );
1068 0 : self->foundation_rate = fd_rng_double_o( rng );
1069 0 : self->prev_epoch_duration_in_years = fd_rng_double_o( rng );
1070 0 : self->capitalization = fd_rng_ulong( rng );
1071 0 : fd_point_value_generate( &self->point_value, alloc_mem, rng );
1072 0 : return mem;
1073 0 : }
1074 :
1075 0 : void *fd_start_block_height_and_rewards_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1076 0 : fd_start_block_height_and_rewards_t *self = (fd_start_block_height_and_rewards_t *) mem;
1077 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_start_block_height_and_rewards_t);
1078 0 : fd_start_block_height_and_rewards_new(mem);
1079 0 : self->distribution_starting_block_height = fd_rng_ulong( rng );
1080 0 : fd_partitioned_stake_rewards_generate( &self->partitioned_stake_rewards, alloc_mem, rng );
1081 0 : return mem;
1082 0 : }
1083 :
1084 0 : void *fd_fd_epoch_reward_status_inner_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1085 0 : fd_fd_epoch_reward_status_inner_t *self = (fd_fd_epoch_reward_status_inner_t *) mem;
1086 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_fd_epoch_reward_status_inner_t);
1087 0 : fd_fd_epoch_reward_status_inner_new(mem);
1088 0 : fd_start_block_height_and_rewards_generate( &self->Active, alloc_mem, rng );
1089 0 : return mem;
1090 0 : }
1091 :
1092 0 : void fd_epoch_reward_status_inner_generate( fd_epoch_reward_status_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
1093 0 : switch (discriminant) {
1094 0 : case 0: {
1095 0 : fd_start_block_height_and_rewards_generate( &self->Active, alloc_mem, rng );
1096 0 : break;
1097 0 : }
1098 0 : }
1099 0 : }
1100 0 : void *fd_epoch_reward_status_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1101 0 : fd_epoch_reward_status_t *self = (fd_epoch_reward_status_t *) mem;
1102 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_epoch_reward_status_t);
1103 0 : fd_epoch_reward_status_new(mem);
1104 0 : self->discriminant = fd_rng_uint( rng ) % 2;
1105 0 : fd_epoch_reward_status_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1106 0 : return mem;
1107 0 : }
1108 :
1109 0 : void *fd_prev_epoch_inflation_rewards_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1110 0 : fd_prev_epoch_inflation_rewards_t *self = (fd_prev_epoch_inflation_rewards_t *) mem;
1111 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_prev_epoch_inflation_rewards_t);
1112 0 : fd_prev_epoch_inflation_rewards_new(mem);
1113 0 : self->validator_rewards = fd_rng_ulong( rng );
1114 0 : self->prev_epoch_duration_in_years = fd_rng_double_o( rng );
1115 0 : self->validator_rate = fd_rng_double_o( rng );
1116 0 : self->foundation_rate = fd_rng_double_o( rng );
1117 0 : return mem;
1118 0 : }
1119 :
1120 0 : void *fd_vote_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1121 0 : fd_vote_t *self = (fd_vote_t *) mem;
1122 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_t);
1123 0 : fd_vote_new(mem);
1124 0 : ulong slots_len = fd_rng_ulong( rng ) % 8;
1125 0 : self->slots = deq_ulong_join_new( alloc_mem, slots_len );
1126 0 : for( ulong i=0; i < slots_len; i++ ) {
1127 0 : ulong * elem = deq_ulong_push_tail_nocopy( self->slots );
1128 0 : LLVMFuzzerMutate( (uchar *) elem, sizeof(ulong), sizeof(ulong) );
1129 0 : }
1130 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
1131 0 : {
1132 0 : self->has_timestamp = fd_rng_uchar( rng ) % 2;
1133 0 : if( self->has_timestamp ) {
1134 0 : LLVMFuzzerMutate( (uchar *)&(self->timestamp), sizeof(long), sizeof(long) );
1135 0 : }
1136 0 : }
1137 0 : return mem;
1138 0 : }
1139 :
1140 0 : void *fd_vote_init_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1141 0 : fd_vote_init_t *self = (fd_vote_init_t *) mem;
1142 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_init_t);
1143 0 : fd_vote_init_new(mem);
1144 0 : fd_pubkey_generate( &self->node_pubkey, alloc_mem, rng );
1145 0 : fd_pubkey_generate( &self->authorized_voter, alloc_mem, rng );
1146 0 : fd_pubkey_generate( &self->authorized_withdrawer, alloc_mem, rng );
1147 0 : self->commission = fd_rng_uchar( rng );
1148 0 : return mem;
1149 0 : }
1150 :
1151 0 : void *fd_vote_authorize_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1152 0 : fd_vote_authorize_t *self = (fd_vote_authorize_t *) mem;
1153 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_authorize_t);
1154 0 : fd_vote_authorize_new(mem);
1155 0 : self->discriminant = fd_rng_uint( rng ) % 2;
1156 0 : return mem;
1157 0 : }
1158 :
1159 0 : void *fd_vote_authorize_pubkey_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1160 0 : fd_vote_authorize_pubkey_t *self = (fd_vote_authorize_pubkey_t *) mem;
1161 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_authorize_pubkey_t);
1162 0 : fd_vote_authorize_pubkey_new(mem);
1163 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
1164 0 : fd_vote_authorize_generate( &self->vote_authorize, alloc_mem, rng );
1165 0 : return mem;
1166 0 : }
1167 :
1168 0 : void *fd_vote_switch_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1169 0 : fd_vote_switch_t *self = (fd_vote_switch_t *) mem;
1170 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_switch_t);
1171 0 : fd_vote_switch_new(mem);
1172 0 : fd_vote_generate( &self->vote, alloc_mem, rng );
1173 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
1174 0 : return mem;
1175 0 : }
1176 :
1177 0 : void *fd_update_vote_state_switch_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1178 0 : fd_update_vote_state_switch_t *self = (fd_update_vote_state_switch_t *) mem;
1179 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_update_vote_state_switch_t);
1180 0 : fd_update_vote_state_switch_new(mem);
1181 0 : fd_vote_state_update_generate( &self->vote_state_update, alloc_mem, rng );
1182 0 : fd_hash_generate( &self->hash, alloc_mem, rng );
1183 0 : return mem;
1184 0 : }
1185 :
1186 0 : void *fd_vote_authorize_with_seed_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1187 0 : fd_vote_authorize_with_seed_args_t *self = (fd_vote_authorize_with_seed_args_t *) mem;
1188 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_authorize_with_seed_args_t);
1189 0 : fd_vote_authorize_with_seed_args_new(mem);
1190 0 : fd_vote_authorize_generate( &self->authorization_type, alloc_mem, rng );
1191 0 : fd_pubkey_generate( &self->current_authority_derived_key_owner, alloc_mem, rng );
1192 0 : self->current_authority_derived_key_seed_len = fd_rng_ulong( rng ) % 8;
1193 0 : if( self->current_authority_derived_key_seed_len ) {
1194 0 : self->current_authority_derived_key_seed = (uchar *) *alloc_mem;
1195 0 : *alloc_mem = (uchar *) *alloc_mem + self->current_authority_derived_key_seed_len;
1196 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; }
1197 0 : } else {
1198 0 : self->current_authority_derived_key_seed = NULL;
1199 0 : }
1200 0 : fd_pubkey_generate( &self->new_authority, alloc_mem, rng );
1201 0 : return mem;
1202 0 : }
1203 :
1204 0 : void *fd_vote_authorize_checked_with_seed_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1205 0 : fd_vote_authorize_checked_with_seed_args_t *self = (fd_vote_authorize_checked_with_seed_args_t *) mem;
1206 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_authorize_checked_with_seed_args_t);
1207 0 : fd_vote_authorize_checked_with_seed_args_new(mem);
1208 0 : fd_vote_authorize_generate( &self->authorization_type, alloc_mem, rng );
1209 0 : fd_pubkey_generate( &self->current_authority_derived_key_owner, alloc_mem, rng );
1210 0 : self->current_authority_derived_key_seed_len = fd_rng_ulong( rng ) % 8;
1211 0 : if( self->current_authority_derived_key_seed_len ) {
1212 0 : self->current_authority_derived_key_seed = (uchar *) *alloc_mem;
1213 0 : *alloc_mem = (uchar *) *alloc_mem + self->current_authority_derived_key_seed_len;
1214 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; }
1215 0 : } else {
1216 0 : self->current_authority_derived_key_seed = NULL;
1217 0 : }
1218 0 : return mem;
1219 0 : }
1220 :
1221 0 : void fd_vote_instruction_inner_generate( fd_vote_instruction_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
1222 0 : switch (discriminant) {
1223 0 : case 0: {
1224 0 : fd_vote_init_generate( &self->initialize_account, alloc_mem, rng );
1225 0 : break;
1226 0 : }
1227 0 : case 1: {
1228 0 : fd_vote_authorize_pubkey_generate( &self->authorize, alloc_mem, rng );
1229 0 : break;
1230 0 : }
1231 0 : case 2: {
1232 0 : fd_vote_generate( &self->vote, alloc_mem, rng );
1233 0 : break;
1234 0 : }
1235 0 : case 3: {
1236 0 : self->withdraw = fd_rng_ulong( rng );
1237 0 : break;
1238 0 : }
1239 0 : case 5: {
1240 0 : self->update_commission = fd_rng_uchar( rng );
1241 0 : break;
1242 0 : }
1243 0 : case 6: {
1244 0 : fd_vote_switch_generate( &self->vote_switch, alloc_mem, rng );
1245 0 : break;
1246 0 : }
1247 0 : case 7: {
1248 0 : fd_vote_authorize_generate( &self->authorize_checked, alloc_mem, rng );
1249 0 : break;
1250 0 : }
1251 0 : case 8: {
1252 0 : fd_vote_state_update_generate( &self->update_vote_state, alloc_mem, rng );
1253 0 : break;
1254 0 : }
1255 0 : case 9: {
1256 0 : fd_update_vote_state_switch_generate( &self->update_vote_state_switch, alloc_mem, rng );
1257 0 : break;
1258 0 : }
1259 0 : case 10: {
1260 0 : fd_vote_authorize_with_seed_args_generate( &self->authorize_with_seed, alloc_mem, rng );
1261 0 : break;
1262 0 : }
1263 0 : case 11: {
1264 0 : fd_vote_authorize_checked_with_seed_args_generate( &self->authorize_checked_with_seed, alloc_mem, rng );
1265 0 : break;
1266 0 : }
1267 0 : case 12: {
1268 0 : fd_compact_vote_state_update_generate( &self->compact_update_vote_state, alloc_mem, rng );
1269 0 : break;
1270 0 : }
1271 0 : case 13: {
1272 0 : fd_compact_vote_state_update_switch_generate( &self->compact_update_vote_state_switch, alloc_mem, rng );
1273 0 : break;
1274 0 : }
1275 0 : case 14: {
1276 0 : break;
1277 0 : }
1278 0 : case 15: {
1279 0 : fd_tower_sync_switch_generate( &self->tower_sync_switch, alloc_mem, rng );
1280 0 : break;
1281 0 : }
1282 0 : }
1283 0 : }
1284 0 : void *fd_vote_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1285 0 : fd_vote_instruction_t *self = (fd_vote_instruction_t *) mem;
1286 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_vote_instruction_t);
1287 0 : fd_vote_instruction_new(mem);
1288 0 : self->discriminant = fd_rng_uint( rng ) % 16;
1289 0 : while( self->discriminant == 14 || self->discriminant == 15 ) { self->discriminant = fd_rng_uint( rng ) % 16; }
1290 0 : fd_vote_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1291 0 : return mem;
1292 0 : }
1293 :
1294 0 : void *fd_system_program_instruction_create_account_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1295 0 : fd_system_program_instruction_create_account_t *self = (fd_system_program_instruction_create_account_t *) mem;
1296 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_program_instruction_create_account_t);
1297 0 : fd_system_program_instruction_create_account_new(mem);
1298 0 : self->lamports = fd_rng_ulong( rng );
1299 0 : self->space = fd_rng_ulong( rng );
1300 0 : fd_pubkey_generate( &self->owner, alloc_mem, rng );
1301 0 : return mem;
1302 0 : }
1303 :
1304 0 : void *fd_system_program_instruction_create_account_with_seed_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1305 0 : fd_system_program_instruction_create_account_with_seed_t *self = (fd_system_program_instruction_create_account_with_seed_t *) mem;
1306 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_program_instruction_create_account_with_seed_t);
1307 0 : fd_system_program_instruction_create_account_with_seed_new(mem);
1308 0 : fd_pubkey_generate( &self->base, alloc_mem, rng );
1309 0 : self->seed_len = fd_rng_ulong( rng ) % 8;
1310 0 : if( self->seed_len ) {
1311 0 : self->seed = (uchar *) *alloc_mem;
1312 0 : *alloc_mem = (uchar *) *alloc_mem + self->seed_len;
1313 0 : for( ulong i=0; i < self->seed_len; ++i) { self->seed[i] = fd_rng_uchar( rng ) % 0x80; }
1314 0 : } else {
1315 0 : self->seed = NULL;
1316 0 : }
1317 0 : self->lamports = fd_rng_ulong( rng );
1318 0 : self->space = fd_rng_ulong( rng );
1319 0 : fd_pubkey_generate( &self->owner, alloc_mem, rng );
1320 0 : return mem;
1321 0 : }
1322 :
1323 0 : void *fd_system_program_instruction_allocate_with_seed_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1324 0 : fd_system_program_instruction_allocate_with_seed_t *self = (fd_system_program_instruction_allocate_with_seed_t *) mem;
1325 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_program_instruction_allocate_with_seed_t);
1326 0 : fd_system_program_instruction_allocate_with_seed_new(mem);
1327 0 : fd_pubkey_generate( &self->base, alloc_mem, rng );
1328 0 : self->seed_len = fd_rng_ulong( rng ) % 8;
1329 0 : if( self->seed_len ) {
1330 0 : self->seed = (uchar *) *alloc_mem;
1331 0 : *alloc_mem = (uchar *) *alloc_mem + self->seed_len;
1332 0 : for( ulong i=0; i < self->seed_len; ++i) { self->seed[i] = fd_rng_uchar( rng ) % 0x80; }
1333 0 : } else {
1334 0 : self->seed = NULL;
1335 0 : }
1336 0 : self->space = fd_rng_ulong( rng );
1337 0 : fd_pubkey_generate( &self->owner, alloc_mem, rng );
1338 0 : return mem;
1339 0 : }
1340 :
1341 0 : void *fd_system_program_instruction_assign_with_seed_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1342 0 : fd_system_program_instruction_assign_with_seed_t *self = (fd_system_program_instruction_assign_with_seed_t *) mem;
1343 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_program_instruction_assign_with_seed_t);
1344 0 : fd_system_program_instruction_assign_with_seed_new(mem);
1345 0 : fd_pubkey_generate( &self->base, alloc_mem, rng );
1346 0 : self->seed_len = fd_rng_ulong( rng ) % 8;
1347 0 : if( self->seed_len ) {
1348 0 : self->seed = (uchar *) *alloc_mem;
1349 0 : *alloc_mem = (uchar *) *alloc_mem + self->seed_len;
1350 0 : for( ulong i=0; i < self->seed_len; ++i) { self->seed[i] = fd_rng_uchar( rng ) % 0x80; }
1351 0 : } else {
1352 0 : self->seed = NULL;
1353 0 : }
1354 0 : fd_pubkey_generate( &self->owner, alloc_mem, rng );
1355 0 : return mem;
1356 0 : }
1357 :
1358 0 : void *fd_system_program_instruction_transfer_with_seed_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1359 0 : fd_system_program_instruction_transfer_with_seed_t *self = (fd_system_program_instruction_transfer_with_seed_t *) mem;
1360 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_program_instruction_transfer_with_seed_t);
1361 0 : fd_system_program_instruction_transfer_with_seed_new(mem);
1362 0 : self->lamports = fd_rng_ulong( rng );
1363 0 : self->from_seed_len = fd_rng_ulong( rng ) % 8;
1364 0 : if( self->from_seed_len ) {
1365 0 : self->from_seed = (uchar *) *alloc_mem;
1366 0 : *alloc_mem = (uchar *) *alloc_mem + self->from_seed_len;
1367 0 : for( ulong i=0; i < self->from_seed_len; ++i) { self->from_seed[i] = fd_rng_uchar( rng ) % 0x80; }
1368 0 : } else {
1369 0 : self->from_seed = NULL;
1370 0 : }
1371 0 : fd_pubkey_generate( &self->from_owner, alloc_mem, rng );
1372 0 : return mem;
1373 0 : }
1374 :
1375 0 : void fd_system_program_instruction_inner_generate( fd_system_program_instruction_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
1376 0 : switch (discriminant) {
1377 0 : case 0: {
1378 0 : fd_system_program_instruction_create_account_generate( &self->create_account, alloc_mem, rng );
1379 0 : break;
1380 0 : }
1381 0 : case 1: {
1382 0 : fd_pubkey_generate( &self->assign, alloc_mem, rng );
1383 0 : break;
1384 0 : }
1385 0 : case 2: {
1386 0 : self->transfer = fd_rng_ulong( rng );
1387 0 : break;
1388 0 : }
1389 0 : case 3: {
1390 0 : fd_system_program_instruction_create_account_with_seed_generate( &self->create_account_with_seed, alloc_mem, rng );
1391 0 : break;
1392 0 : }
1393 0 : case 5: {
1394 0 : self->withdraw_nonce_account = fd_rng_ulong( rng );
1395 0 : break;
1396 0 : }
1397 0 : case 6: {
1398 0 : fd_pubkey_generate( &self->initialize_nonce_account, alloc_mem, rng );
1399 0 : break;
1400 0 : }
1401 0 : case 7: {
1402 0 : fd_pubkey_generate( &self->authorize_nonce_account, alloc_mem, rng );
1403 0 : break;
1404 0 : }
1405 0 : case 8: {
1406 0 : self->allocate = fd_rng_ulong( rng );
1407 0 : break;
1408 0 : }
1409 0 : case 9: {
1410 0 : fd_system_program_instruction_allocate_with_seed_generate( &self->allocate_with_seed, alloc_mem, rng );
1411 0 : break;
1412 0 : }
1413 0 : case 10: {
1414 0 : fd_system_program_instruction_assign_with_seed_generate( &self->assign_with_seed, alloc_mem, rng );
1415 0 : break;
1416 0 : }
1417 0 : case 11: {
1418 0 : fd_system_program_instruction_transfer_with_seed_generate( &self->transfer_with_seed, alloc_mem, rng );
1419 0 : break;
1420 0 : }
1421 0 : }
1422 0 : }
1423 0 : void *fd_system_program_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1424 0 : fd_system_program_instruction_t *self = (fd_system_program_instruction_t *) mem;
1425 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_program_instruction_t);
1426 0 : fd_system_program_instruction_new(mem);
1427 0 : self->discriminant = fd_rng_uint( rng ) % 13;
1428 0 : fd_system_program_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1429 0 : return mem;
1430 0 : }
1431 :
1432 0 : void *fd_system_error_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1433 0 : fd_system_error_t *self = (fd_system_error_t *) mem;
1434 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_system_error_t);
1435 0 : fd_system_error_new(mem);
1436 0 : self->discriminant = fd_rng_uint( rng ) % 9;
1437 0 : return mem;
1438 0 : }
1439 :
1440 0 : void *fd_stake_authorized_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1441 0 : fd_stake_authorized_t *self = (fd_stake_authorized_t *) mem;
1442 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_authorized_t);
1443 0 : fd_stake_authorized_new(mem);
1444 0 : fd_pubkey_generate( &self->staker, alloc_mem, rng );
1445 0 : fd_pubkey_generate( &self->withdrawer, alloc_mem, rng );
1446 0 : return mem;
1447 0 : }
1448 :
1449 0 : void *fd_stake_lockup_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1450 0 : fd_stake_lockup_t *self = (fd_stake_lockup_t *) mem;
1451 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_lockup_t);
1452 0 : fd_stake_lockup_new(mem);
1453 0 : self->unix_timestamp = fd_rng_long( rng );
1454 0 : self->epoch = fd_rng_ulong( rng );
1455 0 : fd_pubkey_generate( &self->custodian, alloc_mem, rng );
1456 0 : return mem;
1457 0 : }
1458 :
1459 0 : void *fd_stake_instruction_initialize_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1460 0 : fd_stake_instruction_initialize_t *self = (fd_stake_instruction_initialize_t *) mem;
1461 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_instruction_initialize_t);
1462 0 : fd_stake_instruction_initialize_new(mem);
1463 0 : fd_stake_authorized_generate( &self->authorized, alloc_mem, rng );
1464 0 : fd_stake_lockup_generate( &self->lockup, alloc_mem, rng );
1465 0 : return mem;
1466 0 : }
1467 :
1468 0 : void *fd_stake_lockup_custodian_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1469 0 : fd_stake_lockup_custodian_args_t *self = (fd_stake_lockup_custodian_args_t *) mem;
1470 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_lockup_custodian_args_t);
1471 0 : fd_stake_lockup_custodian_args_new(mem);
1472 0 : fd_stake_lockup_generate( &self->lockup, alloc_mem, rng );
1473 0 : fd_sol_sysvar_clock_generate( &self->clock, alloc_mem, rng );
1474 0 : {
1475 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
1476 0 : if( !is_null ) {
1477 0 : self->custodian = (fd_pubkey_t *) *alloc_mem;
1478 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t);
1479 0 : fd_pubkey_new( self->custodian );
1480 0 : fd_pubkey_generate( self->custodian, alloc_mem, rng );
1481 0 : }
1482 0 : else {
1483 0 : self->custodian = NULL;
1484 0 : }
1485 0 : }
1486 0 : return mem;
1487 0 : }
1488 :
1489 0 : void *fd_stake_authorize_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1490 0 : fd_stake_authorize_t *self = (fd_stake_authorize_t *) mem;
1491 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_authorize_t);
1492 0 : fd_stake_authorize_new(mem);
1493 0 : self->discriminant = fd_rng_uint( rng ) % 2;
1494 0 : return mem;
1495 0 : }
1496 :
1497 0 : void *fd_stake_instruction_authorize_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1498 0 : fd_stake_instruction_authorize_t *self = (fd_stake_instruction_authorize_t *) mem;
1499 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_instruction_authorize_t);
1500 0 : fd_stake_instruction_authorize_new(mem);
1501 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
1502 0 : fd_stake_authorize_generate( &self->stake_authorize, alloc_mem, rng );
1503 0 : return mem;
1504 0 : }
1505 :
1506 0 : void *fd_authorize_with_seed_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1507 0 : fd_authorize_with_seed_args_t *self = (fd_authorize_with_seed_args_t *) mem;
1508 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_authorize_with_seed_args_t);
1509 0 : fd_authorize_with_seed_args_new(mem);
1510 0 : fd_pubkey_generate( &self->new_authorized_pubkey, alloc_mem, rng );
1511 0 : fd_stake_authorize_generate( &self->stake_authorize, alloc_mem, rng );
1512 0 : self->authority_seed_len = fd_rng_ulong( rng ) % 8;
1513 0 : if( self->authority_seed_len ) {
1514 0 : self->authority_seed = (uchar *) *alloc_mem;
1515 0 : *alloc_mem = (uchar *) *alloc_mem + self->authority_seed_len;
1516 0 : for( ulong i=0; i < self->authority_seed_len; ++i) { self->authority_seed[i] = fd_rng_uchar( rng ) % 0x80; }
1517 0 : } else {
1518 0 : self->authority_seed = NULL;
1519 0 : }
1520 0 : fd_pubkey_generate( &self->authority_owner, alloc_mem, rng );
1521 0 : return mem;
1522 0 : }
1523 :
1524 0 : void *fd_authorize_checked_with_seed_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1525 0 : fd_authorize_checked_with_seed_args_t *self = (fd_authorize_checked_with_seed_args_t *) mem;
1526 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_authorize_checked_with_seed_args_t);
1527 0 : fd_authorize_checked_with_seed_args_new(mem);
1528 0 : fd_stake_authorize_generate( &self->stake_authorize, alloc_mem, rng );
1529 0 : self->authority_seed_len = fd_rng_ulong( rng ) % 8;
1530 0 : if( self->authority_seed_len ) {
1531 0 : self->authority_seed = (uchar *) *alloc_mem;
1532 0 : *alloc_mem = (uchar *) *alloc_mem + self->authority_seed_len;
1533 0 : for( ulong i=0; i < self->authority_seed_len; ++i) { self->authority_seed[i] = fd_rng_uchar( rng ) % 0x80; }
1534 0 : } else {
1535 0 : self->authority_seed = NULL;
1536 0 : }
1537 0 : fd_pubkey_generate( &self->authority_owner, alloc_mem, rng );
1538 0 : return mem;
1539 0 : }
1540 :
1541 0 : void *fd_lockup_checked_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1542 0 : fd_lockup_checked_args_t *self = (fd_lockup_checked_args_t *) mem;
1543 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_lockup_checked_args_t);
1544 0 : fd_lockup_checked_args_new(mem);
1545 0 : {
1546 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
1547 0 : if( !is_null ) {
1548 0 : self->unix_timestamp = (long *) *alloc_mem;
1549 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(long);
1550 0 : LLVMFuzzerMutate( (uchar *)self->unix_timestamp, sizeof(long), sizeof(long) );
1551 0 : }
1552 0 : else {
1553 0 : self->unix_timestamp = NULL;
1554 0 : }
1555 0 : }
1556 0 : {
1557 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
1558 0 : if( !is_null ) {
1559 0 : self->epoch = (ulong *) *alloc_mem;
1560 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong);
1561 0 : LLVMFuzzerMutate( (uchar *)self->epoch, sizeof(ulong), sizeof(ulong) );
1562 0 : }
1563 0 : else {
1564 0 : self->epoch = NULL;
1565 0 : }
1566 0 : }
1567 0 : return mem;
1568 0 : }
1569 :
1570 0 : void *fd_lockup_args_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1571 0 : fd_lockup_args_t *self = (fd_lockup_args_t *) mem;
1572 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_lockup_args_t);
1573 0 : fd_lockup_args_new(mem);
1574 0 : {
1575 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
1576 0 : if( !is_null ) {
1577 0 : self->unix_timestamp = (long *) *alloc_mem;
1578 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(long);
1579 0 : LLVMFuzzerMutate( (uchar *)self->unix_timestamp, sizeof(long), sizeof(long) );
1580 0 : }
1581 0 : else {
1582 0 : self->unix_timestamp = NULL;
1583 0 : }
1584 0 : }
1585 0 : {
1586 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
1587 0 : if( !is_null ) {
1588 0 : self->epoch = (ulong *) *alloc_mem;
1589 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(ulong);
1590 0 : LLVMFuzzerMutate( (uchar *)self->epoch, sizeof(ulong), sizeof(ulong) );
1591 0 : }
1592 0 : else {
1593 0 : self->epoch = NULL;
1594 0 : }
1595 0 : }
1596 0 : {
1597 0 : uchar is_null = fd_rng_uchar( rng ) % 2;
1598 0 : if( !is_null ) {
1599 0 : self->custodian = (fd_pubkey_t *) *alloc_mem;
1600 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t);
1601 0 : fd_pubkey_new( self->custodian );
1602 0 : fd_pubkey_generate( self->custodian, alloc_mem, rng );
1603 0 : }
1604 0 : else {
1605 0 : self->custodian = NULL;
1606 0 : }
1607 0 : }
1608 0 : return mem;
1609 0 : }
1610 :
1611 0 : void fd_stake_instruction_inner_generate( fd_stake_instruction_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
1612 0 : switch (discriminant) {
1613 0 : case 0: {
1614 0 : fd_stake_instruction_initialize_generate( &self->initialize, alloc_mem, rng );
1615 0 : break;
1616 0 : }
1617 0 : case 1: {
1618 0 : fd_stake_instruction_authorize_generate( &self->authorize, alloc_mem, rng );
1619 0 : break;
1620 0 : }
1621 0 : case 3: {
1622 0 : self->split = fd_rng_ulong( rng );
1623 0 : break;
1624 0 : }
1625 0 : case 4: {
1626 0 : self->withdraw = fd_rng_ulong( rng );
1627 0 : break;
1628 0 : }
1629 0 : case 6: {
1630 0 : fd_lockup_args_generate( &self->set_lockup, alloc_mem, rng );
1631 0 : break;
1632 0 : }
1633 0 : case 8: {
1634 0 : fd_authorize_with_seed_args_generate( &self->authorize_with_seed, alloc_mem, rng );
1635 0 : break;
1636 0 : }
1637 0 : case 10: {
1638 0 : fd_stake_authorize_generate( &self->authorize_checked, alloc_mem, rng );
1639 0 : break;
1640 0 : }
1641 0 : case 11: {
1642 0 : fd_authorize_checked_with_seed_args_generate( &self->authorize_checked_with_seed, alloc_mem, rng );
1643 0 : break;
1644 0 : }
1645 0 : case 12: {
1646 0 : fd_lockup_checked_args_generate( &self->set_lockup_checked, alloc_mem, rng );
1647 0 : break;
1648 0 : }
1649 0 : case 16: {
1650 0 : self->move_stake = fd_rng_ulong( rng );
1651 0 : break;
1652 0 : }
1653 0 : case 17: {
1654 0 : self->move_lamports = fd_rng_ulong( rng );
1655 0 : break;
1656 0 : }
1657 0 : }
1658 0 : }
1659 0 : void *fd_stake_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1660 0 : fd_stake_instruction_t *self = (fd_stake_instruction_t *) mem;
1661 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_instruction_t);
1662 0 : fd_stake_instruction_new(mem);
1663 0 : self->discriminant = fd_rng_uint( rng ) % 18;
1664 0 : fd_stake_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1665 0 : return mem;
1666 0 : }
1667 :
1668 0 : void *fd_stake_meta_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1669 0 : fd_stake_meta_t *self = (fd_stake_meta_t *) mem;
1670 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_meta_t);
1671 0 : fd_stake_meta_new(mem);
1672 0 : self->rent_exempt_reserve = fd_rng_ulong( rng );
1673 0 : fd_stake_authorized_generate( &self->authorized, alloc_mem, rng );
1674 0 : fd_stake_lockup_generate( &self->lockup, alloc_mem, rng );
1675 0 : return mem;
1676 0 : }
1677 :
1678 0 : void *fd_stake_flags_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1679 0 : fd_stake_flags_t *self = (fd_stake_flags_t *) mem;
1680 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_flags_t);
1681 0 : fd_stake_flags_new(mem);
1682 0 : self->bits = fd_rng_uchar( rng );
1683 0 : return mem;
1684 0 : }
1685 :
1686 0 : void *fd_stake_state_v2_initialized_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1687 0 : fd_stake_state_v2_initialized_t *self = (fd_stake_state_v2_initialized_t *) mem;
1688 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_state_v2_initialized_t);
1689 0 : fd_stake_state_v2_initialized_new(mem);
1690 0 : fd_stake_meta_generate( &self->meta, alloc_mem, rng );
1691 0 : return mem;
1692 0 : }
1693 :
1694 0 : void *fd_stake_state_v2_stake_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1695 0 : fd_stake_state_v2_stake_t *self = (fd_stake_state_v2_stake_t *) mem;
1696 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_state_v2_stake_t);
1697 0 : fd_stake_state_v2_stake_new(mem);
1698 0 : fd_stake_meta_generate( &self->meta, alloc_mem, rng );
1699 0 : fd_stake_generate( &self->stake, alloc_mem, rng );
1700 0 : fd_stake_flags_generate( &self->stake_flags, alloc_mem, rng );
1701 0 : return mem;
1702 0 : }
1703 :
1704 0 : void fd_stake_state_v2_inner_generate( fd_stake_state_v2_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
1705 0 : switch (discriminant) {
1706 0 : case 1: {
1707 0 : fd_stake_state_v2_initialized_generate( &self->initialized, alloc_mem, rng );
1708 0 : break;
1709 0 : }
1710 0 : case 2: {
1711 0 : fd_stake_state_v2_stake_generate( &self->stake, alloc_mem, rng );
1712 0 : break;
1713 0 : }
1714 0 : }
1715 0 : }
1716 0 : void *fd_stake_state_v2_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1717 0 : fd_stake_state_v2_t *self = (fd_stake_state_v2_t *) mem;
1718 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_stake_state_v2_t);
1719 0 : fd_stake_state_v2_new(mem);
1720 0 : self->discriminant = fd_rng_uint( rng ) % 4;
1721 0 : fd_stake_state_v2_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1722 0 : return mem;
1723 0 : }
1724 :
1725 0 : void *fd_nonce_data_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1726 0 : fd_nonce_data_t *self = (fd_nonce_data_t *) mem;
1727 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_nonce_data_t);
1728 0 : fd_nonce_data_new(mem);
1729 0 : fd_pubkey_generate( &self->authority, alloc_mem, rng );
1730 0 : fd_hash_generate( &self->durable_nonce, alloc_mem, rng );
1731 0 : fd_fee_calculator_generate( &self->fee_calculator, alloc_mem, rng );
1732 0 : return mem;
1733 0 : }
1734 :
1735 0 : void fd_nonce_state_inner_generate( fd_nonce_state_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
1736 0 : switch (discriminant) {
1737 0 : case 1: {
1738 0 : fd_nonce_data_generate( &self->initialized, alloc_mem, rng );
1739 0 : break;
1740 0 : }
1741 0 : }
1742 0 : }
1743 0 : void *fd_nonce_state_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1744 0 : fd_nonce_state_t *self = (fd_nonce_state_t *) mem;
1745 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_nonce_state_t);
1746 0 : fd_nonce_state_new(mem);
1747 0 : self->discriminant = fd_rng_uint( rng ) % 2;
1748 0 : fd_nonce_state_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1749 0 : return mem;
1750 0 : }
1751 :
1752 0 : void fd_nonce_state_versions_inner_generate( fd_nonce_state_versions_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
1753 0 : switch (discriminant) {
1754 0 : case 0: {
1755 0 : fd_nonce_state_generate( &self->legacy, alloc_mem, rng );
1756 0 : break;
1757 0 : }
1758 0 : case 1: {
1759 0 : fd_nonce_state_generate( &self->current, alloc_mem, rng );
1760 0 : break;
1761 0 : }
1762 0 : }
1763 0 : }
1764 0 : void *fd_nonce_state_versions_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1765 0 : fd_nonce_state_versions_t *self = (fd_nonce_state_versions_t *) mem;
1766 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_nonce_state_versions_t);
1767 0 : fd_nonce_state_versions_new(mem);
1768 0 : self->discriminant = fd_rng_uint( rng ) % 2;
1769 0 : fd_nonce_state_versions_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1770 0 : return mem;
1771 0 : }
1772 :
1773 0 : void *fd_compute_budget_program_instruction_request_units_deprecated_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1774 0 : fd_compute_budget_program_instruction_request_units_deprecated_t *self = (fd_compute_budget_program_instruction_request_units_deprecated_t *) mem;
1775 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_compute_budget_program_instruction_request_units_deprecated_t);
1776 0 : fd_compute_budget_program_instruction_request_units_deprecated_new(mem);
1777 0 : self->units = fd_rng_uint( rng );
1778 0 : self->additional_fee = fd_rng_uint( rng );
1779 0 : return mem;
1780 0 : }
1781 :
1782 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 ) {
1783 0 : switch (discriminant) {
1784 0 : case 0: {
1785 0 : fd_compute_budget_program_instruction_request_units_deprecated_generate( &self->request_units_deprecated, alloc_mem, rng );
1786 0 : break;
1787 0 : }
1788 0 : case 1: {
1789 0 : self->request_heap_frame = fd_rng_uint( rng );
1790 0 : break;
1791 0 : }
1792 0 : case 2: {
1793 0 : self->set_compute_unit_limit = fd_rng_uint( rng );
1794 0 : break;
1795 0 : }
1796 0 : case 3: {
1797 0 : self->set_compute_unit_price = fd_rng_ulong( rng );
1798 0 : break;
1799 0 : }
1800 0 : case 4: {
1801 0 : self->set_loaded_accounts_data_size_limit = fd_rng_uint( rng );
1802 0 : break;
1803 0 : }
1804 0 : }
1805 0 : }
1806 0 : void *fd_compute_budget_program_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1807 0 : fd_compute_budget_program_instruction_t *self = (fd_compute_budget_program_instruction_t *) mem;
1808 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_compute_budget_program_instruction_t);
1809 0 : fd_compute_budget_program_instruction_new(mem);
1810 0 : self->discriminant = fd_rng_uint( rng ) % 5;
1811 0 : fd_compute_budget_program_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1812 0 : return mem;
1813 0 : }
1814 :
1815 0 : void *fd_config_keys_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1816 0 : fd_config_keys_t *self = (fd_config_keys_t *) mem;
1817 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_config_keys_t);
1818 0 : fd_config_keys_new(mem);
1819 0 : self->keys_len = fd_rng_ulong( rng ) % 8;
1820 0 : if( self->keys_len ) {
1821 0 : self->keys = (fd_config_keys_pair_t *) *alloc_mem;
1822 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_config_keys_pair_t)*self->keys_len;
1823 0 : for( ulong i=0; i < self->keys_len; i++ ) {
1824 0 : fd_config_keys_pair_new( self->keys + i );
1825 0 : fd_config_keys_pair_generate( self->keys + i, alloc_mem, rng );
1826 0 : }
1827 0 : } else {
1828 0 : self->keys = NULL;
1829 0 : }
1830 0 : return mem;
1831 0 : }
1832 :
1833 0 : void *fd_bpf_loader_program_instruction_write_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1834 0 : fd_bpf_loader_program_instruction_write_t *self = (fd_bpf_loader_program_instruction_write_t *) mem;
1835 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_loader_program_instruction_write_t);
1836 0 : fd_bpf_loader_program_instruction_write_new(mem);
1837 0 : self->offset = fd_rng_uint( rng );
1838 0 : self->bytes_len = fd_rng_ulong( rng ) % 8;
1839 0 : if( self->bytes_len ) {
1840 0 : self->bytes = (uchar *) *alloc_mem;
1841 0 : *alloc_mem = (uchar *) *alloc_mem + self->bytes_len;
1842 0 : for( ulong i=0; i < self->bytes_len; ++i) { self->bytes[i] = fd_rng_uchar( rng ) % 0x80; }
1843 0 : } else {
1844 0 : self->bytes = NULL;
1845 0 : }
1846 0 : return mem;
1847 0 : }
1848 :
1849 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 ) {
1850 0 : switch (discriminant) {
1851 0 : case 0: {
1852 0 : fd_bpf_loader_program_instruction_write_generate( &self->write, alloc_mem, rng );
1853 0 : break;
1854 0 : }
1855 0 : }
1856 0 : }
1857 0 : void *fd_bpf_loader_program_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1858 0 : fd_bpf_loader_program_instruction_t *self = (fd_bpf_loader_program_instruction_t *) mem;
1859 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_loader_program_instruction_t);
1860 0 : fd_bpf_loader_program_instruction_new(mem);
1861 0 : self->discriminant = fd_rng_uint( rng ) % 2;
1862 0 : fd_bpf_loader_program_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1863 0 : return mem;
1864 0 : }
1865 :
1866 0 : void *fd_loader_v4_program_instruction_write_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1867 0 : fd_loader_v4_program_instruction_write_t *self = (fd_loader_v4_program_instruction_write_t *) mem;
1868 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_loader_v4_program_instruction_write_t);
1869 0 : fd_loader_v4_program_instruction_write_new(mem);
1870 0 : self->offset = fd_rng_uint( rng );
1871 0 : self->bytes_len = fd_rng_ulong( rng ) % 8;
1872 0 : if( self->bytes_len ) {
1873 0 : self->bytes = (uchar *) *alloc_mem;
1874 0 : *alloc_mem = (uchar *) *alloc_mem + self->bytes_len;
1875 0 : for( ulong i=0; i < self->bytes_len; ++i) { self->bytes[i] = fd_rng_uchar( rng ) % 0x80; }
1876 0 : } else {
1877 0 : self->bytes = NULL;
1878 0 : }
1879 0 : return mem;
1880 0 : }
1881 :
1882 0 : void *fd_loader_v4_program_instruction_copy_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1883 0 : fd_loader_v4_program_instruction_copy_t *self = (fd_loader_v4_program_instruction_copy_t *) mem;
1884 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_loader_v4_program_instruction_copy_t);
1885 0 : fd_loader_v4_program_instruction_copy_new(mem);
1886 0 : self->destination_offset = fd_rng_uint( rng );
1887 0 : self->source_offset = fd_rng_uint( rng );
1888 0 : self->length = fd_rng_uint( rng );
1889 0 : return mem;
1890 0 : }
1891 :
1892 0 : void *fd_loader_v4_program_instruction_set_program_length_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1893 0 : fd_loader_v4_program_instruction_set_program_length_t *self = (fd_loader_v4_program_instruction_set_program_length_t *) mem;
1894 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_loader_v4_program_instruction_set_program_length_t);
1895 0 : fd_loader_v4_program_instruction_set_program_length_new(mem);
1896 0 : self->new_size = fd_rng_uint( rng );
1897 0 : return mem;
1898 0 : }
1899 :
1900 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 ) {
1901 0 : switch (discriminant) {
1902 0 : case 0: {
1903 0 : fd_loader_v4_program_instruction_write_generate( &self->write, alloc_mem, rng );
1904 0 : break;
1905 0 : }
1906 0 : case 1: {
1907 0 : fd_loader_v4_program_instruction_copy_generate( &self->copy, alloc_mem, rng );
1908 0 : break;
1909 0 : }
1910 0 : case 2: {
1911 0 : fd_loader_v4_program_instruction_set_program_length_generate( &self->set_program_length, alloc_mem, rng );
1912 0 : break;
1913 0 : }
1914 0 : }
1915 0 : }
1916 0 : void *fd_loader_v4_program_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1917 0 : fd_loader_v4_program_instruction_t *self = (fd_loader_v4_program_instruction_t *) mem;
1918 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_loader_v4_program_instruction_t);
1919 0 : fd_loader_v4_program_instruction_new(mem);
1920 0 : self->discriminant = fd_rng_uint( rng ) % 7;
1921 0 : fd_loader_v4_program_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1922 0 : return mem;
1923 0 : }
1924 :
1925 0 : void *fd_bpf_upgradeable_loader_program_instruction_write_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1926 0 : fd_bpf_upgradeable_loader_program_instruction_write_t *self = (fd_bpf_upgradeable_loader_program_instruction_write_t *) mem;
1927 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_write_t);
1928 0 : fd_bpf_upgradeable_loader_program_instruction_write_new(mem);
1929 0 : self->offset = fd_rng_uint( rng );
1930 0 : self->bytes_len = fd_rng_ulong( rng ) % 8;
1931 0 : if( self->bytes_len ) {
1932 0 : self->bytes = (uchar *) *alloc_mem;
1933 0 : *alloc_mem = (uchar *) *alloc_mem + self->bytes_len;
1934 0 : for( ulong i=0; i < self->bytes_len; ++i) { self->bytes[i] = fd_rng_uchar( rng ) % 0x80; }
1935 0 : } else {
1936 0 : self->bytes = NULL;
1937 0 : }
1938 0 : return mem;
1939 0 : }
1940 :
1941 0 : void *fd_bpf_upgradeable_loader_program_instruction_deploy_with_max_data_len_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1942 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;
1943 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_deploy_with_max_data_len_t);
1944 0 : fd_bpf_upgradeable_loader_program_instruction_deploy_with_max_data_len_new(mem);
1945 0 : self->max_data_len = fd_rng_ulong( rng );
1946 0 : return mem;
1947 0 : }
1948 :
1949 0 : void *fd_bpf_upgradeable_loader_program_instruction_extend_program_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1950 0 : fd_bpf_upgradeable_loader_program_instruction_extend_program_t *self = (fd_bpf_upgradeable_loader_program_instruction_extend_program_t *) mem;
1951 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_extend_program_t);
1952 0 : fd_bpf_upgradeable_loader_program_instruction_extend_program_new(mem);
1953 0 : self->additional_bytes = fd_rng_uint( rng );
1954 0 : return mem;
1955 0 : }
1956 :
1957 0 : void *fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1958 0 : fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t *self = (fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t *) mem;
1959 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_t);
1960 0 : fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_new(mem);
1961 0 : self->additional_bytes = fd_rng_uint( rng );
1962 0 : return mem;
1963 0 : }
1964 :
1965 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 ) {
1966 0 : switch (discriminant) {
1967 0 : case 1: {
1968 0 : fd_bpf_upgradeable_loader_program_instruction_write_generate( &self->write, alloc_mem, rng );
1969 0 : break;
1970 0 : }
1971 0 : case 2: {
1972 0 : fd_bpf_upgradeable_loader_program_instruction_deploy_with_max_data_len_generate( &self->deploy_with_max_data_len, alloc_mem, rng );
1973 0 : break;
1974 0 : }
1975 0 : case 6: {
1976 0 : fd_bpf_upgradeable_loader_program_instruction_extend_program_generate( &self->extend_program, alloc_mem, rng );
1977 0 : break;
1978 0 : }
1979 0 : case 9: {
1980 0 : fd_bpf_upgradeable_loader_program_instruction_extend_program_checked_generate( &self->extend_program_checked, alloc_mem, rng );
1981 0 : break;
1982 0 : }
1983 0 : }
1984 0 : }
1985 0 : void *fd_bpf_upgradeable_loader_program_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1986 0 : fd_bpf_upgradeable_loader_program_instruction_t *self = (fd_bpf_upgradeable_loader_program_instruction_t *) mem;
1987 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_program_instruction_t);
1988 0 : fd_bpf_upgradeable_loader_program_instruction_new(mem);
1989 0 : self->discriminant = fd_rng_uint( rng ) % 10;
1990 0 : fd_bpf_upgradeable_loader_program_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
1991 0 : return mem;
1992 0 : }
1993 :
1994 0 : void *fd_bpf_upgradeable_loader_state_buffer_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
1995 0 : fd_bpf_upgradeable_loader_state_buffer_t *self = (fd_bpf_upgradeable_loader_state_buffer_t *) mem;
1996 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_state_buffer_t);
1997 0 : fd_bpf_upgradeable_loader_state_buffer_new(mem);
1998 0 : {
1999 0 : self->has_authority_address = fd_rng_uchar( rng ) % 2;
2000 0 : if( self->has_authority_address ) {
2001 0 : fd_pubkey_generate( &self->authority_address, alloc_mem, rng );
2002 0 : }
2003 0 : }
2004 0 : return mem;
2005 0 : }
2006 :
2007 0 : void *fd_bpf_upgradeable_loader_state_program_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2008 0 : fd_bpf_upgradeable_loader_state_program_t *self = (fd_bpf_upgradeable_loader_state_program_t *) mem;
2009 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_state_program_t);
2010 0 : fd_bpf_upgradeable_loader_state_program_new(mem);
2011 0 : fd_pubkey_generate( &self->programdata_address, alloc_mem, rng );
2012 0 : return mem;
2013 0 : }
2014 :
2015 0 : void *fd_bpf_upgradeable_loader_state_program_data_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2016 0 : fd_bpf_upgradeable_loader_state_program_data_t *self = (fd_bpf_upgradeable_loader_state_program_data_t *) mem;
2017 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_state_program_data_t);
2018 0 : fd_bpf_upgradeable_loader_state_program_data_new(mem);
2019 0 : self->slot = fd_rng_ulong( rng );
2020 0 : {
2021 0 : self->has_upgrade_authority_address = fd_rng_uchar( rng ) % 2;
2022 0 : if( self->has_upgrade_authority_address ) {
2023 0 : fd_pubkey_generate( &self->upgrade_authority_address, alloc_mem, rng );
2024 0 : }
2025 0 : }
2026 0 : return mem;
2027 0 : }
2028 :
2029 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 ) {
2030 0 : switch (discriminant) {
2031 0 : case 1: {
2032 0 : fd_bpf_upgradeable_loader_state_buffer_generate( &self->buffer, alloc_mem, rng );
2033 0 : break;
2034 0 : }
2035 0 : case 2: {
2036 0 : fd_bpf_upgradeable_loader_state_program_generate( &self->program, alloc_mem, rng );
2037 0 : break;
2038 0 : }
2039 0 : case 3: {
2040 0 : fd_bpf_upgradeable_loader_state_program_data_generate( &self->program_data, alloc_mem, rng );
2041 0 : break;
2042 0 : }
2043 0 : }
2044 0 : }
2045 0 : void *fd_bpf_upgradeable_loader_state_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2046 0 : fd_bpf_upgradeable_loader_state_t *self = (fd_bpf_upgradeable_loader_state_t *) mem;
2047 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_bpf_upgradeable_loader_state_t);
2048 0 : fd_bpf_upgradeable_loader_state_new(mem);
2049 0 : self->discriminant = fd_rng_uint( rng ) % 4;
2050 0 : fd_bpf_upgradeable_loader_state_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2051 0 : return mem;
2052 0 : }
2053 :
2054 0 : void *fd_loader_v4_state_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2055 0 : fd_loader_v4_state_t *self = (fd_loader_v4_state_t *) mem;
2056 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_loader_v4_state_t);
2057 0 : fd_loader_v4_state_new(mem);
2058 0 : self->slot = fd_rng_ulong( rng );
2059 0 : fd_pubkey_generate( &self->authority_address_or_next_version, alloc_mem, rng );
2060 0 : self->status = fd_rng_ulong( rng );
2061 0 : return mem;
2062 0 : }
2063 :
2064 0 : void *fd_frozen_hash_status_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2065 0 : fd_frozen_hash_status_t *self = (fd_frozen_hash_status_t *) mem;
2066 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_frozen_hash_status_t);
2067 0 : fd_frozen_hash_status_new(mem);
2068 0 : fd_hash_generate( &self->frozen_hash, alloc_mem, rng );
2069 0 : self->is_duplicate_confirmed = fd_rng_uchar( rng );
2070 0 : return mem;
2071 0 : }
2072 :
2073 0 : void fd_frozen_hash_versioned_inner_generate( fd_frozen_hash_versioned_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2074 0 : switch (discriminant) {
2075 0 : case 0: {
2076 0 : fd_frozen_hash_status_generate( &self->current, alloc_mem, rng );
2077 0 : break;
2078 0 : }
2079 0 : }
2080 0 : }
2081 0 : void *fd_frozen_hash_versioned_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2082 0 : fd_frozen_hash_versioned_t *self = (fd_frozen_hash_versioned_t *) mem;
2083 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_frozen_hash_versioned_t);
2084 0 : fd_frozen_hash_versioned_new(mem);
2085 0 : self->discriminant = fd_rng_uint( rng ) % 1;
2086 0 : fd_frozen_hash_versioned_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2087 0 : return mem;
2088 0 : }
2089 :
2090 0 : void *fd_lookup_table_meta_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2091 0 : fd_lookup_table_meta_t *self = (fd_lookup_table_meta_t *) mem;
2092 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_lookup_table_meta_t);
2093 0 : fd_lookup_table_meta_new(mem);
2094 0 : self->deactivation_slot = fd_rng_ulong( rng );
2095 0 : self->last_extended_slot = fd_rng_ulong( rng );
2096 0 : self->last_extended_slot_start_index = fd_rng_uchar( rng );
2097 0 : {
2098 0 : self->has_authority = fd_rng_uchar( rng ) % 2;
2099 0 : if( self->has_authority ) {
2100 0 : fd_pubkey_generate( &self->authority, alloc_mem, rng );
2101 0 : }
2102 0 : }
2103 0 : self->_padding = fd_rng_ushort( rng );
2104 0 : return mem;
2105 0 : }
2106 :
2107 0 : void *fd_address_lookup_table_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2108 0 : fd_address_lookup_table_t *self = (fd_address_lookup_table_t *) mem;
2109 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_address_lookup_table_t);
2110 0 : fd_address_lookup_table_new(mem);
2111 0 : fd_lookup_table_meta_generate( &self->meta, alloc_mem, rng );
2112 0 : return mem;
2113 0 : }
2114 :
2115 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 ) {
2116 0 : switch (discriminant) {
2117 0 : case 1: {
2118 0 : fd_address_lookup_table_generate( &self->lookup_table, alloc_mem, rng );
2119 0 : break;
2120 0 : }
2121 0 : }
2122 0 : }
2123 0 : void *fd_address_lookup_table_state_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2124 0 : fd_address_lookup_table_state_t *self = (fd_address_lookup_table_state_t *) mem;
2125 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_address_lookup_table_state_t);
2126 0 : fd_address_lookup_table_state_new(mem);
2127 0 : self->discriminant = fd_rng_uint( rng ) % 2;
2128 0 : fd_address_lookup_table_state_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2129 0 : return mem;
2130 0 : }
2131 :
2132 0 : void *fd_gossip_ping_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2133 0 : fd_gossip_ping_t *self = (fd_gossip_ping_t *) mem;
2134 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_gossip_ping_t);
2135 0 : fd_gossip_ping_new(mem);
2136 0 : fd_pubkey_generate( &self->from, alloc_mem, rng );
2137 0 : fd_hash_generate( &self->token, alloc_mem, rng );
2138 0 : fd_signature_generate( &self->signature, alloc_mem, rng );
2139 0 : return mem;
2140 0 : }
2141 :
2142 0 : void *fd_addrlut_create_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2143 0 : fd_addrlut_create_t *self = (fd_addrlut_create_t *) mem;
2144 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_addrlut_create_t);
2145 0 : fd_addrlut_create_new(mem);
2146 0 : self->recent_slot = fd_rng_ulong( rng );
2147 0 : self->bump_seed = fd_rng_uchar( rng );
2148 0 : return mem;
2149 0 : }
2150 :
2151 0 : void *fd_addrlut_extend_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2152 0 : fd_addrlut_extend_t *self = (fd_addrlut_extend_t *) mem;
2153 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_addrlut_extend_t);
2154 0 : fd_addrlut_extend_new(mem);
2155 0 : self->new_addrs_len = fd_rng_ulong( rng ) % 8;
2156 0 : if( self->new_addrs_len ) {
2157 0 : self->new_addrs = (fd_pubkey_t *) *alloc_mem;
2158 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_t)*self->new_addrs_len;
2159 0 : for( ulong i=0; i < self->new_addrs_len; i++ ) {
2160 0 : fd_pubkey_new( self->new_addrs + i );
2161 0 : fd_pubkey_generate( self->new_addrs + i, alloc_mem, rng );
2162 0 : }
2163 0 : } else {
2164 0 : self->new_addrs = NULL;
2165 0 : }
2166 0 : return mem;
2167 0 : }
2168 :
2169 0 : void fd_addrlut_instruction_inner_generate( fd_addrlut_instruction_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2170 0 : switch (discriminant) {
2171 0 : case 0: {
2172 0 : fd_addrlut_create_generate( &self->create_lut, alloc_mem, rng );
2173 0 : break;
2174 0 : }
2175 0 : case 2: {
2176 0 : fd_addrlut_extend_generate( &self->extend_lut, alloc_mem, rng );
2177 0 : break;
2178 0 : }
2179 0 : }
2180 0 : }
2181 0 : void *fd_addrlut_instruction_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2182 0 : fd_addrlut_instruction_t *self = (fd_addrlut_instruction_t *) mem;
2183 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_addrlut_instruction_t);
2184 0 : fd_addrlut_instruction_new(mem);
2185 0 : self->discriminant = fd_rng_uint( rng ) % 5;
2186 0 : fd_addrlut_instruction_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2187 0 : return mem;
2188 0 : }
2189 :
2190 0 : void *fd_repair_request_header_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2191 0 : fd_repair_request_header_t *self = (fd_repair_request_header_t *) mem;
2192 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_request_header_t);
2193 0 : fd_repair_request_header_new(mem);
2194 0 : fd_signature_generate( &self->signature, alloc_mem, rng );
2195 0 : fd_pubkey_generate( &self->sender, alloc_mem, rng );
2196 0 : fd_pubkey_generate( &self->recipient, alloc_mem, rng );
2197 0 : self->timestamp = fd_rng_ulong( rng );
2198 0 : self->nonce = fd_rng_uint( rng );
2199 0 : return mem;
2200 0 : }
2201 :
2202 0 : void *fd_repair_window_index_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2203 0 : fd_repair_window_index_t *self = (fd_repair_window_index_t *) mem;
2204 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_window_index_t);
2205 0 : fd_repair_window_index_new(mem);
2206 0 : fd_repair_request_header_generate( &self->header, alloc_mem, rng );
2207 0 : self->slot = fd_rng_ulong( rng );
2208 0 : self->shred_index = fd_rng_ulong( rng );
2209 0 : return mem;
2210 0 : }
2211 :
2212 0 : void *fd_repair_highest_window_index_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2213 0 : fd_repair_highest_window_index_t *self = (fd_repair_highest_window_index_t *) mem;
2214 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_highest_window_index_t);
2215 0 : fd_repair_highest_window_index_new(mem);
2216 0 : fd_repair_request_header_generate( &self->header, alloc_mem, rng );
2217 0 : self->slot = fd_rng_ulong( rng );
2218 0 : self->shred_index = fd_rng_ulong( rng );
2219 0 : return mem;
2220 0 : }
2221 :
2222 0 : void *fd_repair_orphan_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2223 0 : fd_repair_orphan_t *self = (fd_repair_orphan_t *) mem;
2224 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_orphan_t);
2225 0 : fd_repair_orphan_new(mem);
2226 0 : fd_repair_request_header_generate( &self->header, alloc_mem, rng );
2227 0 : self->slot = fd_rng_ulong( rng );
2228 0 : return mem;
2229 0 : }
2230 :
2231 0 : void *fd_repair_ancestor_hashes_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2232 0 : fd_repair_ancestor_hashes_t *self = (fd_repair_ancestor_hashes_t *) mem;
2233 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_ancestor_hashes_t);
2234 0 : fd_repair_ancestor_hashes_new(mem);
2235 0 : fd_repair_request_header_generate( &self->header, alloc_mem, rng );
2236 0 : self->slot = fd_rng_ulong( rng );
2237 0 : return mem;
2238 0 : }
2239 :
2240 0 : void fd_repair_protocol_inner_generate( fd_repair_protocol_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2241 0 : switch (discriminant) {
2242 0 : case 7: {
2243 0 : fd_gossip_ping_generate( &self->pong, alloc_mem, rng );
2244 0 : break;
2245 0 : }
2246 0 : case 8: {
2247 0 : fd_repair_window_index_generate( &self->window_index, alloc_mem, rng );
2248 0 : break;
2249 0 : }
2250 0 : case 9: {
2251 0 : fd_repair_highest_window_index_generate( &self->highest_window_index, alloc_mem, rng );
2252 0 : break;
2253 0 : }
2254 0 : case 10: {
2255 0 : fd_repair_orphan_generate( &self->orphan, alloc_mem, rng );
2256 0 : break;
2257 0 : }
2258 0 : case 11: {
2259 0 : fd_repair_ancestor_hashes_generate( &self->ancestor_hashes, alloc_mem, rng );
2260 0 : break;
2261 0 : }
2262 0 : }
2263 0 : }
2264 0 : void *fd_repair_protocol_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2265 0 : fd_repair_protocol_t *self = (fd_repair_protocol_t *) mem;
2266 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_protocol_t);
2267 0 : fd_repair_protocol_new(mem);
2268 0 : self->discriminant = fd_rng_uint( rng ) % 12;
2269 0 : fd_repair_protocol_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2270 0 : return mem;
2271 0 : }
2272 :
2273 0 : void fd_repair_response_inner_generate( fd_repair_response_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2274 0 : switch (discriminant) {
2275 0 : case 0: {
2276 0 : fd_gossip_ping_generate( &self->ping, alloc_mem, rng );
2277 0 : break;
2278 0 : }
2279 0 : }
2280 0 : }
2281 0 : void *fd_repair_response_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2282 0 : fd_repair_response_t *self = (fd_repair_response_t *) mem;
2283 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_repair_response_t);
2284 0 : fd_repair_response_new(mem);
2285 0 : self->discriminant = fd_rng_uint( rng ) % 1;
2286 0 : fd_repair_response_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2287 0 : return mem;
2288 0 : }
2289 :
2290 0 : void fd_instr_error_enum_inner_generate( fd_instr_error_enum_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2291 0 : switch (discriminant) {
2292 0 : case 25: {
2293 0 : self->custom = fd_rng_uint( rng );
2294 0 : break;
2295 0 : }
2296 0 : case 44: {
2297 0 : ulong slen = fd_rng_ulong( rng ) % 256;
2298 0 : char *buffer = (char *) *alloc_mem;
2299 0 : *alloc_mem = (uchar *) *alloc_mem + slen;
2300 0 : self->borsh_io_error = buffer;
2301 0 : LLVMFuzzerMutate( (uchar *)self->borsh_io_error, slen, slen );
2302 0 : self->borsh_io_error[slen] = '\0';
2303 0 : break;
2304 0 : }
2305 0 : }
2306 0 : }
2307 0 : void *fd_instr_error_enum_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2308 0 : fd_instr_error_enum_t *self = (fd_instr_error_enum_t *) mem;
2309 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_instr_error_enum_t);
2310 0 : fd_instr_error_enum_new(mem);
2311 0 : self->discriminant = fd_rng_uint( rng ) % 54;
2312 0 : fd_instr_error_enum_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2313 0 : return mem;
2314 0 : }
2315 :
2316 0 : void *fd_txn_instr_error_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2317 0 : fd_txn_instr_error_t *self = (fd_txn_instr_error_t *) mem;
2318 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_txn_instr_error_t);
2319 0 : fd_txn_instr_error_new(mem);
2320 0 : self->instr_idx = fd_rng_uchar( rng );
2321 0 : fd_instr_error_enum_generate( &self->error, alloc_mem, rng );
2322 0 : return mem;
2323 0 : }
2324 :
2325 0 : void fd_txn_error_enum_inner_generate( fd_txn_error_enum_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2326 0 : switch (discriminant) {
2327 0 : case 8: {
2328 0 : fd_txn_instr_error_generate( &self->instruction_error, alloc_mem, rng );
2329 0 : break;
2330 0 : }
2331 0 : case 30: {
2332 0 : self->duplicate_instruction = fd_rng_uchar( rng );
2333 0 : break;
2334 0 : }
2335 0 : case 31: {
2336 0 : self->insufficient_funds_for_rent = fd_rng_uchar( rng );
2337 0 : break;
2338 0 : }
2339 0 : case 35: {
2340 0 : self->program_execution_temporarily_restricted = fd_rng_uchar( rng );
2341 0 : break;
2342 0 : }
2343 0 : }
2344 0 : }
2345 0 : void *fd_txn_error_enum_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2346 0 : fd_txn_error_enum_t *self = (fd_txn_error_enum_t *) mem;
2347 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_txn_error_enum_t);
2348 0 : fd_txn_error_enum_new(mem);
2349 0 : self->discriminant = fd_rng_uint( rng ) % 37;
2350 0 : fd_txn_error_enum_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2351 0 : return mem;
2352 0 : }
2353 :
2354 0 : void fd_txn_result_inner_generate( fd_txn_result_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2355 0 : switch (discriminant) {
2356 0 : case 1: {
2357 0 : fd_txn_error_enum_generate( &self->error, alloc_mem, rng );
2358 0 : break;
2359 0 : }
2360 0 : }
2361 0 : }
2362 0 : void *fd_txn_result_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2363 0 : fd_txn_result_t *self = (fd_txn_result_t *) mem;
2364 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_txn_result_t);
2365 0 : fd_txn_result_new(mem);
2366 0 : self->discriminant = fd_rng_uint( rng ) % 2;
2367 0 : fd_txn_result_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2368 0 : return mem;
2369 0 : }
2370 :
2371 0 : void *fd_pubkey_rewardinfo_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2372 0 : fd_pubkey_rewardinfo_pair_t *self = (fd_pubkey_rewardinfo_pair_t *) mem;
2373 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_pubkey_rewardinfo_pair_t);
2374 0 : fd_pubkey_rewardinfo_pair_new(mem);
2375 0 : fd_pubkey_generate( &self->pubkey, alloc_mem, rng );
2376 0 : fd_reward_info_generate( &self->reward_info, alloc_mem, rng );
2377 0 : return mem;
2378 0 : }
2379 :
2380 0 : void *fd_calculated_stake_points_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2381 0 : fd_calculated_stake_points_t *self = (fd_calculated_stake_points_t *) mem;
2382 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_calculated_stake_points_t);
2383 0 : fd_calculated_stake_points_new(mem);
2384 0 : self->points = fd_rng_uint128( rng );
2385 0 : self->new_credits_observed = fd_rng_ulong( rng );
2386 0 : self->force_credits_update_with_skipped_reward = fd_rng_uchar( rng );
2387 0 : return mem;
2388 0 : }
2389 :
2390 0 : void *fd_calculated_stake_rewards_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2391 0 : fd_calculated_stake_rewards_t *self = (fd_calculated_stake_rewards_t *) mem;
2392 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_calculated_stake_rewards_t);
2393 0 : fd_calculated_stake_rewards_new(mem);
2394 0 : self->staker_rewards = fd_rng_ulong( rng );
2395 0 : self->voter_rewards = fd_rng_ulong( rng );
2396 0 : self->new_credits_observed = fd_rng_ulong( rng );
2397 0 : return mem;
2398 0 : }
2399 :
2400 0 : void *fd_duplicate_slot_proof_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2401 0 : fd_duplicate_slot_proof_t *self = (fd_duplicate_slot_proof_t *) mem;
2402 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_duplicate_slot_proof_t);
2403 0 : fd_duplicate_slot_proof_new(mem);
2404 0 : self->shred1_len = fd_rng_ulong( rng ) % 8;
2405 0 : if( self->shred1_len ) {
2406 0 : self->shred1 = (uchar *) *alloc_mem;
2407 0 : *alloc_mem = (uchar *) *alloc_mem + self->shred1_len;
2408 0 : for( ulong i=0; i < self->shred1_len; ++i) { self->shred1[i] = fd_rng_uchar( rng ) % 0x80; }
2409 0 : } else {
2410 0 : self->shred1 = NULL;
2411 0 : }
2412 0 : self->shred2_len = fd_rng_ulong( rng ) % 8;
2413 0 : if( self->shred2_len ) {
2414 0 : self->shred2 = (uchar *) *alloc_mem;
2415 0 : *alloc_mem = (uchar *) *alloc_mem + self->shred2_len;
2416 0 : for( ulong i=0; i < self->shred2_len; ++i) { self->shred2[i] = fd_rng_uchar( rng ) % 0x80; }
2417 0 : } else {
2418 0 : self->shred2 = NULL;
2419 0 : }
2420 0 : return mem;
2421 0 : }
2422 :
2423 0 : void *fd_epoch_info_pair_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2424 0 : fd_epoch_info_pair_t *self = (fd_epoch_info_pair_t *) mem;
2425 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_epoch_info_pair_t);
2426 0 : fd_epoch_info_pair_new(mem);
2427 0 : fd_pubkey_generate( &self->account, alloc_mem, rng );
2428 0 : fd_stake_generate( &self->stake, alloc_mem, rng );
2429 0 : return mem;
2430 0 : }
2431 :
2432 0 : void *fd_usage_cost_details_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2433 0 : fd_usage_cost_details_t *self = (fd_usage_cost_details_t *) mem;
2434 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_usage_cost_details_t);
2435 0 : fd_usage_cost_details_new(mem);
2436 0 : self->signature_cost = fd_rng_ulong( rng );
2437 0 : self->write_lock_cost = fd_rng_ulong( rng );
2438 0 : self->data_bytes_cost = fd_rng_ulong( rng );
2439 0 : self->programs_execution_cost = fd_rng_ulong( rng );
2440 0 : self->loaded_accounts_data_size_cost = fd_rng_ulong( rng );
2441 0 : self->allocated_accounts_data_size = fd_rng_ulong( rng );
2442 0 : return mem;
2443 0 : }
2444 :
2445 0 : void fd_transaction_cost_inner_generate( fd_transaction_cost_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2446 0 : switch (discriminant) {
2447 0 : case 1: {
2448 0 : fd_usage_cost_details_generate( &self->transaction, alloc_mem, rng );
2449 0 : break;
2450 0 : }
2451 0 : }
2452 0 : }
2453 0 : void *fd_transaction_cost_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2454 0 : fd_transaction_cost_t *self = (fd_transaction_cost_t *) mem;
2455 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_transaction_cost_t);
2456 0 : fd_transaction_cost_new(mem);
2457 0 : self->discriminant = fd_rng_uint( rng ) % 2;
2458 0 : fd_transaction_cost_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2459 0 : return mem;
2460 0 : }
2461 :
2462 0 : void *fd_rent_paying_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2463 0 : fd_rent_paying_t *self = (fd_rent_paying_t *) mem;
2464 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_rent_paying_t);
2465 0 : fd_rent_paying_new(mem);
2466 0 : self->lamports = fd_rng_ulong( rng );
2467 0 : self->data_size = fd_rng_ulong( rng );
2468 0 : return mem;
2469 0 : }
2470 :
2471 0 : void fd_rent_state_inner_generate( fd_rent_state_inner_t * self, void **alloc_mem, uint discriminant, fd_rng_t * rng ) {
2472 0 : switch (discriminant) {
2473 0 : case 1: {
2474 0 : fd_rent_paying_generate( &self->rent_paying, alloc_mem, rng );
2475 0 : break;
2476 0 : }
2477 0 : }
2478 0 : }
2479 0 : void *fd_rent_state_generate( void *mem, void **alloc_mem, fd_rng_t * rng ) {
2480 0 : fd_rent_state_t *self = (fd_rent_state_t *) mem;
2481 0 : *alloc_mem = (uchar *) *alloc_mem + sizeof(fd_rent_state_t);
2482 0 : fd_rent_state_new(mem);
2483 0 : self->discriminant = fd_rng_uint( rng ) % 3;
2484 0 : fd_rent_state_inner_generate( &self->inner, alloc_mem, self->discriminant, rng );
2485 0 : return mem;
2486 0 : }
2487 :
2488 : #endif // HEADER_FUZZ_FD_RUNTIME_TYPES
|
