Line data    Source code

       1             : #include "fd_solfuzz_private.h"
       2             : #include "generated/context.pb.h"
       3             : #include "../fd_runtime.h"
       4             : #include "../fd_bank.h"
       5             : #include "../fd_system_ids.h"
       6             : #include "../../features/fd_features.h"
       7             : 
       8             : void
       9             : fd_solfuzz_pb_restore_fee_rate_governor( fd_bank_t *                              bank,
      10           0 :                                          fd_exec_test_fee_rate_governor_t const * fee_rate_governor ) {
      11           0 :   fd_fee_rate_governor_t * frg = &bank->f.fee_rate_governor;
      12           0 :   *frg = (fd_fee_rate_governor_t){
      13           0 :     .target_lamports_per_signature = fee_rate_governor->target_lamports_per_signature,
      14           0 :     .target_signatures_per_slot    = fee_rate_governor->target_signatures_per_slot,
      15           0 :     .min_lamports_per_signature    = fee_rate_governor->min_lamports_per_signature,
      16           0 :     .max_lamports_per_signature    = fee_rate_governor->max_lamports_per_signature,
      17           0 :     .burn_percent                  = (uchar)fee_rate_governor->burn_percent,
      18           0 :   };
      19           0 : }
      20             : 
      21             : void
      22             : fd_solfuzz_pb_restore_blockhash_queue( fd_bank_t *                                    bank,
      23             :                                        fd_exec_test_blockhash_queue_entry_t const *   entries,
      24           0 :                                        ulong                                          entries_cnt ) {
      25           0 :   ulong blockhash_seed; FD_TEST( fd_rng_secure( &blockhash_seed, sizeof(ulong) ) );
      26           0 :   fd_blockhashes_t * blockhashes = fd_blockhashes_init( &bank->f.block_hash_queue, blockhash_seed );
      27           0 :   for( ulong i=0UL; i<entries_cnt; i++ ) {
      28           0 :     fd_hash_t hash                   = FD_LOAD( fd_hash_t, entries[i].blockhash );
      29           0 :     ulong     lamports_per_signature = entries[i].lamports_per_signature;
      30             : 
      31           0 :     fd_blockhash_info_t * blockhash = fd_blockhashes_push_new( blockhashes, &hash );
      32           0 :     blockhash->lamports_per_signature = lamports_per_signature;
      33           0 :   }
      34           0 : }
      35             : 
      36             : ulong
      37             : fd_solfuzz_pb_get_slot( fd_exec_test_acct_state_t const * acct_states,
      38           0 :                         ulong                             acct_states_cnt ) {
      39           0 :   for( ulong i=0UL; i<acct_states_cnt; i++ ) {
      40           0 :     if( !memcmp( &acct_states[i].address, &fd_sysvar_clock_id, sizeof(fd_pubkey_t) ) ) {
      41           0 :       pb_bytes_array_t const * data = fd_solfuzz_acct_data( &acct_states[i] );
      42           0 :       FD_TEST( data && data->size==sizeof(fd_sol_sysvar_clock_t) );
      43           0 :       return FD_LOAD( ulong, data->bytes );
      44           0 :     }
      45           0 :   }
      46           0 :   FD_LOG_ERR(( "invariant violation: clock sysvar account not found in acct states" ));
      47           0 : }
      48             : 
      49             : int
      50             : fd_solfuzz_pb_load_account( fd_runtime_t *                    runtime,
      51             :                             fd_accdb_t *                      accdb,
      52             :                             fd_accdb_fork_id_t                fork_id,
      53             :                             fd_exec_test_acct_state_t const * state,
      54           0 :                             ulong                             acc_idx ) {
      55           0 :   (void)runtime; (void)acc_idx;
      56           0 :   if( state->lamports==0UL ) return 0;
      57             : 
      58           0 :   pb_bytes_array_t const * state_data = fd_solfuzz_acct_data( state );
      59           0 :   ulong size = state_data ? state_data->size : 0UL;
      60             : 
      61           0 :   fd_pubkey_t pubkey[1];  memcpy( pubkey, state->address, sizeof(fd_pubkey_t) );
      62             : 
      63             :   /* Account must not yet exist */
      64           0 :   if( FD_UNLIKELY( fd_accdb_exists( accdb, fork_id, pubkey->key ) ) ) {
      65           0 :     return 0;
      66           0 :   }
      67             : 
      68           0 :   fd_acc_t acc = fd_accdb_write_one( accdb, fork_id, pubkey->key );
      69           0 :   if( size ) {
      70           0 :     fd_memcpy( acc.data, state_data->bytes, size );
      71           0 :   }
      72           0 :   acc.data_len   = size;
      73           0 :   acc.lamports   = state->lamports;
      74           0 :   acc.executable = state->executable;
      75           0 :   fd_memcpy( acc.owner, state->owner, 32UL );
      76           0 :   acc.commit = 1;
      77           0 :   fd_accdb_unwrite_one( accdb, &acc );
      78             : 
      79           0 :   return 1;
      80           0 : }
      81             : 
      82             : int
      83             : fd_solfuzz_pb_restore_features( fd_features_t *                    features,
      84           0 :                                 fd_exec_test_feature_set_t const * feature_set ) {
      85           0 :   fd_features_disable_all( features );
      86           0 :   for( ulong j=0UL; j < feature_set->features_count; j++ ) {
      87           0 :     ulong                   prefix = feature_set->features[j];
      88           0 :     fd_feature_id_t const * id     = fd_feature_id_query( prefix );
      89           0 :     if( FD_UNLIKELY( !id ) ) {
      90           0 :       FD_LOG_WARNING(( "unsupported feature ID 0x%016lx", prefix ));
      91           0 :       return 0;
      92           0 :     }
      93           0 :     if( FD_UNLIKELY( !id->implemented ) ) {
      94           0 :       FD_LOG_WARNING(( "unimplemented feature %s", id->name ));
      95           0 :       return 0;
      96           0 :     }
      97             :     /* Enabled since genesis */
      98           0 :     fd_features_set( features, id, 0UL );
      99           0 :   }
     100           0 :   return 1;
     101           0 : }
     102             : 
     103             : void
     104             : fd_solfuzz_direct_mapping_handle_cu_exhaustion( fd_solfuzz_runner_t *       runner,
     105             :                                                 ulong                       cu_avail,
     106             :                                                 int                         has_err,
     107             :                                                 fd_exec_test_acct_state_t * accounts,
     108           0 :                                                 pb_size_t                   accounts_cnt ) {
     109           0 :   if( FD_FEATURE_ACTIVE_BANK( runner->bank, virtual_address_space_adjustments )
     110           0 :       && cu_avail == 0UL
     111           0 :       && has_err ) {
     112           0 :     for( pb_size_t i=0; i<accounts_cnt; i++ ) {
     113           0 :       fd_solfuzz_acct_set_data_hash( &accounts[i], NULL, 0UL );
     114           0 :     }
     115           0 :   }
     116           0 : }
     117             : 
     118             : void
     119             : fd_solfuzz_pb_create_feature_accounts( fd_accdb_t *                       accdb,
     120             :                                        fd_accdb_fork_id_t                 fork_id,
     121             :                                        fd_exec_test_feature_set_t const * feature_set,
     122             :                                        fd_exec_test_acct_state_t const *  acct_states,
     123           0 :                                        pb_size_t                          acct_states_count ) {
     124           0 :   for( ulong j=0UL; j<feature_set->features_count; j++ ) {
     125           0 :     fd_feature_id_t const * id = fd_feature_id_query( feature_set->features[j] );
     126           0 :     if( FD_UNLIKELY( !id ) ) continue;
     127             : 
     128             :     /* Skip if an acct_state already owns this pubkey so the
     129             :        caller-supplied state wins. */
     130           0 :     int collision = 0;
     131           0 :     for( pb_size_t i=0U; i<acct_states_count; i++ ) {
     132           0 :       if( !memcmp( acct_states[i].address, id->id.key, sizeof(fd_pubkey_t) ) ) {
     133           0 :         collision = 1;
     134           0 :         break;
     135           0 :       }
     136           0 :     }
     137           0 :     if( collision ) continue;
     138             : 
     139             :     /* Genesis activation slot */
     140           0 :     fd_feature_t feature = { .is_active = 1, .activation_slot = 0UL };
     141             : 
     142           0 :     fd_acc_t acc = fd_accdb_write_one( accdb, fork_id, id->id.key );
     143           0 :     fd_memcpy( acc.data, &feature, sizeof(feature) );
     144           0 :     acc.data_len   = sizeof(feature);
     145           0 :     acc.lamports   = 100000000UL;
     146           0 :     acc.executable = 0;
     147           0 :     fd_memcpy( acc.owner, fd_solana_feature_program_id.key, sizeof(fd_pubkey_t) );
     148           0 :     acc.commit = 1;
     149           0 :     fd_accdb_unwrite_one( accdb, &acc );
     150           0 :   }
     151           0 : }