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