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