[2.0] feat: harness: api to process fixtures (#42)

Author: buffalojoec

harness/src/fuzz/firedancer.rs

@@ -8,6 +8,7 @@ use {
     crate::{
         accounts::{compile_accounts, CompiledAccounts},
         result::{Check, InstructionResult},
+        sysvar::Sysvars,
         Mollusk, DEFAULT_LOADER_KEY,
     },
     mollusk_svm_fuzz_fixture_firedancer::{
@@ -19,9 +20,10 @@ use {
         metadata::Metadata as FuzzMetadata,
         Fixture as FuzzFixture,
     },
+    solana_compute_budget::compute_budget::ComputeBudget,
     solana_sdk::{
         account::AccountSharedData,
-        instruction::{Instruction, InstructionError},
+        instruction::{AccountMeta, Instruction, InstructionError},
         pubkey::Pubkey,
     },
 };
@@ -54,6 +56,16 @@ fn instr_err_to_num(error: &InstructionError) -> i32 {
     i32::from_le_bytes((&serialized_err[0..4]).try_into().unwrap()) + 1
 }
 
+fn num_to_instr_err(num: i32, custom_code: u32) -> InstructionError {
+    let val = (num - 1) as u64;
+    let le = val.to_le_bytes();
+    let mut deser = bincode::deserialize(&le).unwrap();
+    if custom_code != 0 && matches!(deser, InstructionError::Custom(_)) {
+        deser = InstructionError::Custom(custom_code);
+    }
+    deser
+}
+
 fn build_fixture_context(
     mollusk: &Mollusk,
     instruction: &Instruction,
@@ -98,6 +110,56 @@ fn build_fixture_context(
     }
 }
 
+fn parse_fixture_context(
+    context: &FuzzContext,
+) -> (Mollusk, Instruction, Vec<(Pubkey, AccountSharedData)>) {
+    let FuzzContext {
+        program_id,
+        accounts,
+        instruction_accounts,
+        instruction_data,
+        compute_units_available,
+        epoch_context,
+        ..
+    } = context;
+
+    let compute_budget = ComputeBudget {
+        compute_unit_limit: *compute_units_available,
+        ..Default::default()
+    };
+
+    let accounts = accounts
+        .iter()
+        .map(|(key, acct, _)| (*key, acct.clone()))
+        .collect::<Vec<_>>();
+
+    let mollusk = Mollusk {
+        compute_budget,
+        feature_set: epoch_context.feature_set.clone(),
+        sysvars: Sysvars::fill_from_accounts(&accounts),
+        ..Default::default()
+    };
+
+    let metas = instruction_accounts
+        .iter()
+        .map(|ia| {
+            let pubkey = accounts
+                .get(ia.index_in_caller as usize)
+                .expect("Index out of bounds")
+                .0;
+            AccountMeta {
+                pubkey,
+                is_signer: ia.is_signer,
+                is_writable: ia.is_writable,
+            }
+        })
+        .collect::<Vec<_>>();
+
+    let instruction = Instruction::new_with_bytes(*program_id, instruction_data, metas);
+
+    (mollusk, instruction, accounts)
+}
+
 fn build_fixture_effects(context: &FuzzContext, result: &InstructionResult) -> FuzzEffects {
     let mut program_custom_code = 0;
     let program_result = match &result.raw_result {
@@ -136,6 +198,47 @@ fn build_fixture_effects(context: &FuzzContext, result: &InstructionResult) -> F
     }
 }
 
+fn parse_fixture_effects(
+    mollusk: &Mollusk,
+    accounts: &[(Pubkey, AccountSharedData)],
+    effects: &FuzzEffects,
+) -> InstructionResult {
+    let raw_result = if effects.program_result == 0 {
+        Ok(())
+    } else {
+        Err(num_to_instr_err(
+            effects.program_result,
+            effects.program_custom_code,
+        ))
+    };
+
+    let program_result = raw_result.clone().into();
+
+    let resulting_accounts = accounts
+        .iter()
+        .map(|(key, acct)| {
+            let resulting_account = effects
+                .modified_accounts
+                .iter()
+                .find(|(k, _, _)| k == key)
+                .map(|(_, acct, _)| acct.clone())
+                .unwrap_or_else(|| acct.clone());
+            (*key, resulting_account)
+        })
+        .collect();
+
+    InstructionResult {
+        program_result,
+        raw_result,
+        execution_time: 0, // TODO: Omitted for now.
+        compute_units_consumed: mollusk
+            .compute_budget
+            .compute_unit_limit
+            .saturating_sub(effects.compute_units_available),
+        resulting_accounts,
+    }
+}
+
 fn instruction_metadata() -> FuzzMetadata {
     FuzzMetadata {
         // Mollusk is always an instruction harness.
@@ -160,3 +263,50 @@ pub fn build_fixture_from_mollusk_test(
         output,
     }
 }
+
+pub fn load_firedancer_fixture(
+    fixture: &mollusk_svm_fuzz_fixture_firedancer::Fixture,
+) -> (
+    Mollusk,
+    Instruction,
+    Vec<(Pubkey, AccountSharedData)>,
+    InstructionResult,
+) {
+    let (mollusk, instruction, accounts) = parse_fixture_context(&fixture.input);
+    let result = parse_fixture_effects(&mollusk, &accounts, &fixture.output);
+    (mollusk, instruction, accounts, result)
+}
+
+#[test]
+fn test_num_to_instr_err() {
+    [
+        InstructionError::InvalidArgument,
+        InstructionError::InvalidInstructionData,
+        InstructionError::InvalidAccountData,
+        InstructionError::AccountDataTooSmall,
+        InstructionError::InsufficientFunds,
+        InstructionError::IncorrectProgramId,
+        InstructionError::MissingRequiredSignature,
+        InstructionError::AccountAlreadyInitialized,
+        InstructionError::UninitializedAccount,
+        InstructionError::UnbalancedInstruction,
+        InstructionError::ModifiedProgramId,
+        InstructionError::Custom(0),
+        InstructionError::Custom(1),
+        InstructionError::Custom(2),
+        InstructionError::Custom(5),
+        InstructionError::Custom(400),
+        InstructionError::Custom(600),
+        InstructionError::Custom(1_000),
+    ]
+    .into_iter()
+    .for_each(|ie| {
+        let mut custom_code = 0;
+        if let InstructionError::Custom(c) = &ie {
+            custom_code = *c;
+        }
+        let result = instr_err_to_num(&ie);
+        let err = num_to_instr_err(result, custom_code);
+        assert_eq!(ie, err);
+    })
+}

harness/src/fuzz/mod.rs

@@ -1,7 +1,7 @@
 #[cfg(feature = "fuzz-fd")]
-mod firedancer;
+pub mod firedancer;
 #[cfg(feature = "fuzz")]
-mod mollusk;
+pub mod mollusk;
 
 use {
     crate::{

harness/src/fuzz/mollusk.rs

@@ -15,8 +15,11 @@ use {
         sysvars::Sysvars as FuzzSysvars, Fixture as FuzzFixture,
     },
     solana_sdk::{
-        account::AccountSharedData, instruction::Instruction, pubkey::Pubkey,
+        account::AccountSharedData,
+        instruction::{Instruction, InstructionError},
+        pubkey::Pubkey,
         slot_hashes::SlotHashes,
+        sysvar::last_restart_slot::LastRestartSlot,
     },
 };
 
@@ -34,26 +37,63 @@ impl From<&Sysvars> for FuzzSysvars {
     }
 }
 
+impl From<&FuzzSysvars> for Sysvars {
+    fn from(input: &FuzzSysvars) -> Self {
+        let slot_hashes = SlotHashes::new(&input.slot_hashes);
+        Self {
+            clock: input.clock.clone(),
+            epoch_rewards: input.epoch_rewards.clone(),
+            epoch_schedule: input.epoch_schedule.clone(),
+            last_restart_slot: LastRestartSlot::default(),
+            rent: input.rent.clone(),
+            slot_hashes,
+            stake_history: input.stake_history.clone(),
+        }
+    }
+}
+
 impl From<&InstructionResult> for FuzzEffects {
     fn from(input: &InstructionResult) -> Self {
         let compute_units_consumed = input.compute_units_consumed;
         let execution_time = input.execution_time;
+
         let program_result = match &input.program_result {
             ProgramResult::Success => 0,
             ProgramResult::Failure(e) => u64::from(e.clone()) as u32,
             ProgramResult::UnknownError(_) => u32::MAX, //TODO
         };
 
-        let resulting_accounts = input
-            .resulting_accounts
-            .iter()
-            .map(|(pubkey, account)| (*pubkey, account.clone()))
-            .collect();
+        let resulting_accounts = input.resulting_accounts.clone();
+
+        Self {
+            compute_units_consumed,
+            execution_time,
+            program_result,
+            resulting_accounts,
+        }
+    }
+}
+
+impl From<&FuzzEffects> for InstructionResult {
+    fn from(input: &FuzzEffects) -> Self {
+        let compute_units_consumed = input.compute_units_consumed;
+        let execution_time = input.execution_time;
+
+        let raw_result = if input.program_result == 0 {
+            Ok(())
+        } else {
+            Err(InstructionError::from(input.program_result))
+        };
+
+        let program_result = raw_result.clone().into();
+
+        let resulting_accounts = input.resulting_accounts.clone();
 
         Self {
             compute_units_consumed,
             execution_time,
             program_result,
+            raw_result,
             resulting_accounts,
         }
     }
@@ -86,6 +126,34 @@ fn build_fixture_context(
     }
 }
 
+fn parse_fixture_context(
+    context: &FuzzContext,
+) -> (Mollusk, Instruction, Vec<(Pubkey, AccountSharedData)>) {
+    let FuzzContext {
+        compute_budget,
+        feature_set,
+        sysvars,
+        program_id,
+        instruction_accounts,
+        instruction_data,
+        accounts,
+    } = context;
+
+    let mollusk = Mollusk {
+        compute_budget: *compute_budget,
+        feature_set: feature_set.clone(),
+        sysvars: sysvars.into(),
+        ..Default::default()
+    };
+
+    let instruction =
+        Instruction::new_with_bytes(*program_id, instruction_data, instruction_accounts.clone());
+
+    let accounts = accounts.clone();
+
+    (mollusk, instruction, accounts)
+}
+
 pub fn build_fixture_from_mollusk_test(
     mollusk: &Mollusk,
     instruction: &Instruction,
@@ -99,3 +167,16 @@ pub fn build_fixture_from_mollusk_test(
     let output = FuzzEffects::from(result);
     FuzzFixture { input, output }
 }
+
+pub fn load_fixture(
+    fixture: &mollusk_svm_fuzz_fixture::Fixture,
+) -> (
+    Mollusk,
+    Instruction,
+    Vec<(Pubkey, AccountSharedData)>,
+    InstructionResult,
+) {
+    let (mollusk, instruction, accounts) = parse_fixture_context(&fixture.input);
+    let result = InstructionResult::from(&fixture.output);
+    (mollusk, instruction, accounts, result)
+}