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             : #include "../../accdb/fd_accdb_sync.h"
       8             : #include <assert.h>
       9             : 
      10             : void
      11             : fd_solfuzz_pb_restore_fee_rate_governor( fd_bank_t *                              bank,
      12           0 :                                          fd_exec_test_fee_rate_governor_t const * fee_rate_governor ) {
      13           0 :   fd_fee_rate_governor_t * frg = &bank->f.fee_rate_governor;
      14           0 :   *frg = (fd_fee_rate_governor_t){
      15           0 :     .target_lamports_per_signature = fee_rate_governor->target_lamports_per_signature,
      16           0 :     .target_signatures_per_slot    = fee_rate_governor->target_signatures_per_slot,
      17           0 :     .min_lamports_per_signature    = fee_rate_governor->min_lamports_per_signature,
      18           0 :     .max_lamports_per_signature    = fee_rate_governor->max_lamports_per_signature,
      19           0 :     .burn_percent                  = (uchar)fee_rate_governor->burn_percent,
      20           0 :   };
      21           0 : }
      22             : 
      23             : void
      24             : fd_solfuzz_pb_restore_epoch_schedule( fd_bank_t *                           bank,
      25           0 :                                       fd_exec_test_epoch_schedule_t const * epoch_schedule ) {
      26           0 :   fd_epoch_schedule_t * es = &bank->f.epoch_schedule;
      27           0 :   *es = (fd_epoch_schedule_t){
      28           0 :     .slots_per_epoch             = epoch_schedule->slots_per_epoch,
      29           0 :     .leader_schedule_slot_offset = epoch_schedule->leader_schedule_slot_offset,
      30           0 :     .warmup                      = epoch_schedule->warmup,
      31           0 :     .first_normal_epoch          = epoch_schedule->first_normal_epoch,
      32           0 :     .first_normal_slot           = epoch_schedule->first_normal_slot,
      33           0 :   };
      34           0 : }
      35             : 
      36             : void
      37             : fd_solfuzz_pb_restore_blockhash_queue( fd_bank_t *                                    bank,
      38             :                                        fd_exec_test_blockhash_queue_entry_t const *   entries,
      39           0 :                                        ulong                                          entries_cnt ) {
      40           0 :   ulong blockhash_seed; FD_TEST( fd_rng_secure( &blockhash_seed, sizeof(ulong) ) );
      41           0 :   fd_blockhashes_t * blockhashes = fd_blockhashes_init( &bank->f.block_hash_queue, blockhash_seed );
      42           0 :   for( ulong i=0UL; i<entries_cnt; i++ ) {
      43           0 :     fd_hash_t hash                   = FD_LOAD( fd_hash_t, entries[i].blockhash );
      44           0 :     ulong     lamports_per_signature = entries[i].lamports_per_signature;
      45             : 
      46           0 :     fd_blockhash_info_t * blockhash = fd_blockhashes_push_new( blockhashes, &hash );
      47           0 :     blockhash->lamports_per_signature = lamports_per_signature;
      48           0 :   }
      49           0 : }
      50             : 
      51             : ulong
      52             : fd_solfuzz_pb_get_slot( fd_exec_test_acct_state_t const * acct_states,
      53           0 :                         ulong                             acct_states_cnt ) {
      54           0 :   for( ulong i=0UL; i<acct_states_cnt; i++ ) {
      55           0 :     if( !memcmp( &acct_states[i].address, &fd_sysvar_clock_id, sizeof(fd_pubkey_t) ) ) {
      56           0 :       FD_TEST( acct_states[i].data->size==sizeof(fd_sol_sysvar_clock_t) );
      57           0 :       return FD_LOAD( ulong, acct_states[i].data->bytes );
      58           0 :     }
      59           0 :   }
      60           0 :   FD_LOG_ERR(( "invariant violation: clock sysvar account not found in acct states" ));
      61           0 : }
      62             : 
      63             : int
      64             : fd_solfuzz_pb_load_account( fd_runtime_t *                    runtime,
      65             :                             fd_accdb_user_t *                 accdb,
      66             :                             fd_funk_txn_xid_t const *         xid,
      67             :                             fd_exec_test_acct_state_t const * state,
      68           0 :                             ulong                             acc_idx ) {
      69           0 :   if( state->lamports==0UL ) return 0;
      70             : 
      71           0 :   ulong size = 0UL;
      72           0 :   if( state->data ) size = state->data->size;
      73             : 
      74           0 :   fd_pubkey_t pubkey[1];  memcpy( pubkey, state->address, sizeof(fd_pubkey_t) );
      75             : 
      76             :   /* Account must not yet exist */
      77           0 :   fd_accdb_ro_t ro[1];
      78           0 :   if( FD_UNLIKELY( fd_accdb_open_ro( accdb, ro, xid, pubkey ) ) ) {
      79           0 :     fd_accdb_close_ro( accdb, ro );
      80           0 :     return 0;
      81           0 :   }
      82             : 
      83           0 :   fd_accdb_rw_t rw[1];
      84           0 :   fd_accdb_open_rw( accdb, rw, xid, pubkey, size, FD_ACCDB_FLAG_CREATE );
      85           0 :   if( state->data ) {
      86           0 :     fd_accdb_ref_data_set( accdb, rw, state->data->bytes, size );
      87           0 :   }
      88           0 :   runtime->accounts.starting_lamports[ acc_idx ] = state->lamports;
      89           0 :   runtime->accounts.starting_dlen    [ acc_idx ] = size;
      90           0 :   fd_accdb_ref_lamports_set( rw, state->lamports   );
      91           0 :   fd_accdb_ref_exec_bit_set( rw, state->executable );
      92           0 :   fd_accdb_ref_owner_set   ( rw, state->owner      );
      93           0 :   fd_accdb_close_rw( accdb, rw );
      94             : 
      95           0 :   return 1;
      96           0 : }
      97             : 
      98             : int
      99             : fd_solfuzz_pb_restore_features( fd_features_t *                    features,
     100           0 :                                 fd_exec_test_feature_set_t const * feature_set ) {
     101           0 :   fd_features_disable_all( features );
     102           0 :   for( ulong j=0UL; j < feature_set->features_count; j++ ) {
     103           0 :     ulong                   prefix = feature_set->features[j];
     104           0 :     fd_feature_id_t const * id     = fd_feature_id_query( prefix );
     105           0 :     if( FD_UNLIKELY( !id ) ) {
     106           0 :       FD_LOG_WARNING(( "unsupported feature ID 0x%016lx", prefix ));
     107           0 :       return 0;
     108           0 :     }
     109             :     /* Enabled since genesis */
     110           0 :     fd_features_set( features, id, 0UL );
     111           0 :   }
     112           0 :   return 1;
     113           0 : }
     114             : 
     115             : void
     116             : fd_solfuzz_direct_mapping_handle_cu_exhaustion( fd_solfuzz_runner_t *       runner,
     117             :                                                 ulong                       cu_avail,
     118             :                                                 int                         has_err,
     119             :                                                 fd_exec_test_acct_state_t * accounts,
     120           0 :                                                 pb_size_t                   accounts_cnt ) {
     121           0 :   if( FD_FEATURE_ACTIVE_BANK( runner->bank, virtual_address_space_adjustments )
     122           0 :       && cu_avail == 0UL
     123           0 :       && has_err ) {
     124           0 :     for( pb_size_t i=0; i<accounts_cnt; i++ ) {
     125           0 :       accounts[i].data = NULL;
     126           0 :     }
     127           0 :   }
     128           0 : }
     129             : 
     130             : void
     131             : fd_solfuzz_pb_create_feature_accounts( fd_accdb_user_t *                  accdb,
     132             :                                        fd_funk_txn_xid_t const *          xid,
     133             :                                        fd_exec_test_feature_set_t const * feature_set,
     134             :                                        fd_exec_test_acct_state_t const *  acct_states,
     135           0 :                                        pb_size_t                          acct_states_count ) {
     136           0 :   for( ulong j=0UL; j<feature_set->features_count; j++ ) {
     137           0 :     fd_feature_id_t const * id = fd_feature_id_query( feature_set->features[j] );
     138           0 :     if( FD_UNLIKELY( !id ) ) continue;
     139             : 
     140             :     /* Skip if an acct_state already owns this pubkey so the
     141             :        caller-supplied state wins. */
     142           0 :     int collision = 0;
     143           0 :     for( pb_size_t i=0U; i<acct_states_count; i++ ) {
     144           0 :       if( !memcmp( acct_states[i].address, id->id.key, sizeof(fd_pubkey_t) ) ) {
     145           0 :         collision = 1;
     146           0 :         break;
     147           0 :       }
     148           0 :     }
     149           0 :     if( collision ) continue;
     150             : 
     151             :     /* Genesis activation slot */
     152           0 :     fd_feature_t feature = { .is_active = 1, .activation_slot = 0UL };
     153           0 :     uchar feature_data[ sizeof(fd_feature_t) ];
     154           0 :     fd_memcpy( feature_data, &feature, sizeof(feature) );
     155             : 
     156           0 :     fd_accdb_rw_t rw[1];
     157           0 :     FD_TEST( fd_accdb_open_rw( accdb, rw, xid, &id->id, sizeof(feature_data), FD_ACCDB_FLAG_CREATE ) );
     158           0 :     fd_accdb_ref_data_set    ( accdb, rw, feature_data, sizeof(feature_data) );
     159             : 
     160           0 :     fd_accdb_ref_lamports_set( rw, 100000000 );
     161           0 :     fd_accdb_ref_exec_bit_set( rw, 0 );
     162           0 :     fd_memcpy( rw->meta->owner, fd_solana_feature_program_id.key, sizeof(fd_pubkey_t) );
     163           0 :     fd_accdb_close_rw( accdb, rw );
     164           0 :   }
     165           0 : }