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 :       FD_TEST( acct_states[i].data->size==sizeof(fd_sol_sysvar_clock_t) );
      42           0 :       return FD_LOAD( ulong, acct_states[i].data->bytes );
      43           0 :     }
      44           0 :   }
      45           0 :   FD_LOG_ERR(( "invariant violation: clock sysvar account not found in acct states" ));
      46           0 : }
      47             : 
      48             : int
      49             : fd_solfuzz_pb_load_account( fd_runtime_t *                    runtime,
      50             :                             fd_accdb_t *                      accdb,
      51             :                             fd_accdb_fork_id_t                fork_id,
      52             :                             fd_exec_test_acct_state_t const * state,
      53           0 :                             ulong                             acc_idx ) {
      54           0 :   (void)runtime; (void)acc_idx;
      55           0 :   if( state->lamports==0UL ) return 0;
      56             : 
      57           0 :   ulong size = 0UL;
      58           0 :   if( state->data ) size = state->data->size;
      59             : 
      60           0 :   fd_pubkey_t pubkey[1];  memcpy( pubkey, state->address, sizeof(fd_pubkey_t) );
      61             : 
      62             :   /* Account must not yet exist */
      63           0 :   if( FD_UNLIKELY( fd_accdb_exists( accdb, fork_id, pubkey->key ) ) ) {
      64           0 :     return 0;
      65           0 :   }
      66             : 
      67           0 :   fd_acc_t acc = fd_accdb_write_one( accdb, fork_id, pubkey->key );
      68           0 :   if( state->data && size ) {
      69           0 :     fd_memcpy( acc.data, state->data->bytes, size );
      70           0 :   }
      71           0 :   acc.data_len   = size;
      72           0 :   acc.lamports   = state->lamports;
      73           0 :   acc.executable = state->executable;
      74           0 :   fd_memcpy( acc.owner, state->owner, 32UL );
      75           0 :   acc.commit = 1;
      76           0 :   fd_accdb_unwrite_one( accdb, &acc );
      77             : 
      78           0 :   return 1;
      79           0 : }
      80             : 
      81             : int
      82             : fd_solfuzz_pb_restore_features( fd_features_t *                    features,
      83           0 :                                 fd_exec_test_feature_set_t const * feature_set ) {
      84           0 :   fd_features_disable_all( features );
      85           0 :   for( ulong j=0UL; j < feature_set->features_count; j++ ) {
      86           0 :     ulong                   prefix = feature_set->features[j];
      87           0 :     fd_feature_id_t const * id     = fd_feature_id_query( prefix );
      88           0 :     if( FD_UNLIKELY( !id ) ) {
      89           0 :       FD_LOG_WARNING(( "unsupported feature ID 0x%016lx", prefix ));
      90           0 :       return 0;
      91           0 :     }
      92             :     /* Enabled since genesis */
      93           0 :     fd_features_set( features, id, 0UL );
      94           0 :   }
      95           0 :   return 1;
      96           0 : }
      97             : 
      98             : void
      99             : fd_solfuzz_direct_mapping_handle_cu_exhaustion( fd_solfuzz_runner_t *       runner,
     100             :                                                 ulong                       cu_avail,
     101             :                                                 int                         has_err,
     102             :                                                 fd_exec_test_acct_state_t * accounts,
     103           0 :                                                 pb_size_t                   accounts_cnt ) {
     104           0 :   if( FD_FEATURE_ACTIVE_BANK( runner->bank, virtual_address_space_adjustments )
     105           0 :       && cu_avail == 0UL
     106           0 :       && has_err ) {
     107           0 :     for( pb_size_t i=0; i<accounts_cnt; i++ ) {
     108           0 :       accounts[i].data = NULL;
     109           0 :     }
     110           0 :   }
     111           0 : }
     112             : 
     113             : void
     114             : fd_solfuzz_pb_create_feature_accounts( fd_accdb_t *                       accdb,
     115             :                                        fd_accdb_fork_id_t                 fork_id,
     116             :                                        fd_exec_test_feature_set_t const * feature_set,
     117             :                                        fd_exec_test_acct_state_t const *  acct_states,
     118           0 :                                        pb_size_t                          acct_states_count ) {
     119           0 :   for( ulong j=0UL; j<feature_set->features_count; j++ ) {
     120           0 :     fd_feature_id_t const * id = fd_feature_id_query( feature_set->features[j] );
     121           0 :     if( FD_UNLIKELY( !id ) ) continue;
     122             : 
     123             :     /* Skip if an acct_state already owns this pubkey so the
     124             :        caller-supplied state wins. */
     125           0 :     int collision = 0;
     126           0 :     for( pb_size_t i=0U; i<acct_states_count; i++ ) {
     127           0 :       if( !memcmp( acct_states[i].address, id->id.key, sizeof(fd_pubkey_t) ) ) {
     128           0 :         collision = 1;
     129           0 :         break;
     130           0 :       }
     131           0 :     }
     132           0 :     if( collision ) continue;
     133             : 
     134             :     /* Genesis activation slot */
     135           0 :     fd_feature_t feature = { .is_active = 1, .activation_slot = 0UL };
     136             : 
     137           0 :     fd_acc_t acc = fd_accdb_write_one( accdb, fork_id, id->id.key );
     138           0 :     fd_memcpy( acc.data, &feature, sizeof(feature) );
     139           0 :     acc.data_len   = sizeof(feature);
     140           0 :     acc.lamports   = 100000000UL;
     141           0 :     acc.executable = 0;
     142           0 :     fd_memcpy( acc.owner, fd_solana_feature_program_id.key, sizeof(fd_pubkey_t) );
     143           0 :     acc.commit = 1;
     144           0 :     fd_accdb_unwrite_one( accdb, &acc );
     145           0 :   }
     146           0 : }