support fuzz fixtures in ix chains (#79)

Author: buffalojoec

harness/src/lib.rs

@@ -26,6 +26,11 @@
 //! * `process_instruction`: Process an instruction and return the result.
 //! * `process_and_validate_instruction`: Process an instruction and perform a
 //!   series of checks on the result, panicking if any checks fail.
+//! * `process_instruction_chain`: Process a chain of instructions and return
+//!   the result.
+//! * `process_and_validate_instruction_chain`: Process a chain of instructions
+//!   and perform a series of checks on each result, panicking if any checks
+//!   fail.
 
 mod accounts;
 pub mod file;
@@ -273,11 +278,7 @@ impl Mollusk {
         for instruction in instructions {
             let this_result = self.process_instruction(instruction, &result.resulting_accounts);
 
-            result.compute_units_consumed += this_result.compute_units_consumed;
-            result.execution_time += this_result.execution_time;
-            result.program_result = this_result.program_result;
-            result.raw_result = this_result.raw_result;
-            result.resulting_accounts = this_result.resulting_accounts;
+            result.absorb(this_result);
 
             if result.program_result.is_err() {
                 break;
@@ -327,17 +328,51 @@ impl Mollusk {
     /// Process a chain of instructions using the minified Solana Virtual
     /// Machine (SVM) environment, then perform checks on the result.
     /// Panics if any checks fail.
+    ///
+    /// For `fuzz` feature only:
+    ///
+    /// Similar to `process_and_validate_instruction`, if the
+    /// `EJECT_FUZZ_FIXTURES` environment variable is set, this function will
+    /// convert the provided test to a set of fuzz fixtures - each of which
+    /// corresponds to a single instruction in the chain - and write them to
+    /// the provided directory.
+    ///
+    /// ```ignore
+    /// EJECT_FUZZ_FIXTURES="./fuzz-fixtures" cargo test-sbf ...
+    /// ```
+    ///
+    /// You can also provide `EJECT_FUZZ_FIXTURES_JSON` to write the fixture in
+    /// JSON format.
+    ///
+    /// The `fuzz-fd` feature works the same way, but the variables require
+    /// the `_FD` suffix, in case both features are active together
+    /// (ie. `EJECT_FUZZ_FIXTURES_FD`). This will generate Firedancer fuzzing
+    /// fixtures, which are structured a bit differently than Mollusk's own
+    /// protobuf layouts.
     pub fn process_and_validate_instruction_chain(
         &self,
-        instructions: &[Instruction],
+        instructions: &[(&Instruction, &[Check])],
         accounts: &[(Pubkey, Account)],
-        checks: &[Check],
     ) -> InstructionResult {
-        let result = self.process_instruction_chain(instructions, accounts);
+        let mut result = InstructionResult {
+            resulting_accounts: accounts.to_vec(),
+            ..Default::default()
+        };
 
-        // No fuzz support yet...
+        for (instruction, checks) in instructions.iter() {
+            let this_result = self.process_and_validate_instruction(
+                instruction,
+                &result.resulting_accounts,
+                checks,
+            );
+
+            result.absorb(this_result);
+
+            if result.program_result.is_err() {
+                break;
+            }
+        }
 
-        result.run_checks(checks);
         result
     }
 

harness/src/result.rs

@@ -207,6 +207,15 @@ impl InstructionResult {
         }
     }
 
+    pub(crate) fn absorb(&mut self, other: Self) {
+        self.compute_units_consumed += other.compute_units_consumed;
+        self.execution_time += other.execution_time;
+        self.program_result = other.program_result;
+        self.raw_result = other.raw_result;
+        self.return_data = other.return_data;
+        self.resulting_accounts = other.resulting_accounts;
+    }
+
     /// Compare an `InstructionResult` against another `InstructionResult`,
     /// panicking on any mismatches.
     pub fn compare(&self, b: &Self) {

harness/tests/dump_fixture.rs

@@ -195,6 +195,34 @@ fn test_dump_mollusk() {
     // Ensure both files have the same name.
     assert_filenames_match(&blob_fixture_path, &json_fixture_path);
 
+    // Now check instruction chains.
+    clear(EJECT_FUZZ_FIXTURES);
+
+    setup.mollusk.process_and_validate_instruction_chain(
+        &[
+            (&setup.instruction, &[]),
+            (&setup.instruction, &[]),
+            (&setup.instruction, &[]),
+        ],
+        &setup.accounts,
+    );
+
+    // Ensure there are three of each fixture type in the target directory.
+    let dir = std::fs::read_dir(EJECT_FUZZ_FIXTURES).unwrap();
+    let mut count_blob = 0;
+    let mut count_json = 0;
+    for entry in dir {
+        let path = entry.unwrap().path();
+        if is_fixture_file(&path, &FileType::Blob) {
+            count_blob += 1;
+        }
+        if is_fixture_file(&path, &FileType::Json) {
+            count_json += 1;
+        }
+    }
+    assert_eq!(count_blob, 3);
+    assert_eq!(count_json, 3);
+
     std::env::remove_var("EJECT_FUZZ_FIXTURES");
     std::env::remove_var("EJECT_FUZZ_FIXTURES_JSON");
     clear(EJECT_FUZZ_FIXTURES);
@@ -235,6 +263,34 @@ fn test_dump_firedancer() {
     // Ensure both files have the same name.
     assert_filenames_match(&blob_fixture_path, &json_fixture_path);
 
+    // Now check instruction chains.
+    clear(EJECT_FUZZ_FIXTURES_FD);
+
+    setup.mollusk.process_and_validate_instruction_chain(
+        &[
+            (&setup.instruction, &[]),
+            (&setup.instruction, &[]),
+            (&setup.instruction, &[]),
+        ],
+        &setup.accounts,
+    );
+
+    // Ensure there are three of each fixture type in the target directory.
+    let dir = std::fs::read_dir(EJECT_FUZZ_FIXTURES_FD).unwrap();
+    let mut count_blob = 0;
+    let mut count_json = 0;
+    for entry in dir {
+        let path = entry.unwrap().path();
+        if is_fixture_file(&path, &FileType::Blob) {
+            count_blob += 1;
+        }
+        if is_fixture_file(&path, &FileType::Json) {
+            count_json += 1;
+        }
+    }
+    assert_eq!(count_blob, 3);
+    assert_eq!(count_json, 3);
+
     std::env::remove_var("EJECT_FUZZ_FIXTURES_FD");
     std::env::remove_var("EJECT_FUZZ_FIXTURES_JSON_FD");
     clear(EJECT_FUZZ_FIXTURES_FD);

harness/tests/instruction_chain.rs

@@ -30,31 +30,70 @@ fn test_transfers() {
 
     mollusk.process_and_validate_instruction_chain(
         &[
-            system_instruction::transfer(&alice, &bob, alice_to_bob),
-            system_instruction::transfer(&bob, &carol, bob_to_carol),
-            system_instruction::transfer(&bob, &dave, bob_to_dave),
+            (
+                // 0: Alice to Bob
+                &system_instruction::transfer(&alice, &bob, alice_to_bob),
+                &[
+                    Check::success(),
+                    Check::account(&alice)
+                        .lamports(starting_lamports - alice_to_bob) // Alice pays
+                        .build(),
+                    Check::account(&bob)
+                        .lamports(starting_lamports + alice_to_bob) // Bob receives
+                        .build(),
+                    Check::account(&carol)
+                        .lamports(starting_lamports) // Unchanged
+                        .build(),
+                    Check::account(&dave)
+                        .lamports(starting_lamports) // Unchanged
+                        .build(),
+                ],
+            ),
+            (
+                // 1: Bob to Carol
+                &system_instruction::transfer(&bob, &carol, bob_to_carol),
+                &[
+                    Check::success(),
+                    Check::account(&alice)
+                        .lamports(starting_lamports - alice_to_bob) // Unchanged
+                        .build(),
+                    Check::account(&bob)
+                        .lamports(starting_lamports + alice_to_bob - bob_to_carol) // Bob pays
+                        .build(),
+                    Check::account(&carol)
+                        .lamports(starting_lamports + bob_to_carol) // Carol receives
+                        .build(),
+                    Check::account(&dave)
+                        .lamports(starting_lamports) // Unchanged
+                        .build(),
+                ],
+            ),
+            (
+                // 2: Bob to Dave
+                &system_instruction::transfer(&bob, &dave, bob_to_dave),
+                &[
+                    Check::success(),
+                    Check::account(&alice)
+                        .lamports(starting_lamports - alice_to_bob) // Unchanged
+                        .build(),
+                    Check::account(&bob)
+                        .lamports(starting_lamports + alice_to_bob - bob_to_carol - bob_to_dave) // Bob pays
+                        .build(),
+                    Check::account(&carol)
+                        .lamports(starting_lamports + bob_to_carol) // Unchanged
+                        .build(),
+                    Check::account(&dave)
+                        .lamports(starting_lamports + bob_to_dave) // Dave receives
+                        .build(),
+                ],
+            ),
         ],
         &[
             (alice, system_account_with_lamports(starting_lamports)),
             (bob, system_account_with_lamports(starting_lamports)),
             (carol, system_account_with_lamports(starting_lamports)),
             (dave, system_account_with_lamports(starting_lamports)),
         ],
-        &[
-            Check::success(),
-            Check::account(&alice)
-                .lamports(starting_lamports - alice_to_bob)
-                .build(),
-            Check::account(&bob)
-                .lamports(starting_lamports + alice_to_bob - bob_to_carol - bob_to_dave)
-                .build(),
-            Check::account(&carol)
-                .lamports(starting_lamports + bob_to_carol)
-                .build(),
-            Check::account(&dave)
-                .lamports(starting_lamports + bob_to_dave)
-                .build(),
-        ],
     );
 }
 
@@ -117,15 +156,27 @@ fn test_mixed() {
 
     mollusk.process_and_validate_instruction_chain(
         &[
-            ix_transfer_to_1,
-            ix_transfer_to_2,
-            ix_allocate_1,
-            ix_allocate_2,
-            ix_assign_1,
-            ix_assign_2,
-            ix_write_data_to_1,
-            ix_write_data_to_2,
-            ix_close_1,
+            (&ix_transfer_to_1, &[]),
+            (&ix_transfer_to_2, &[]),
+            (&ix_allocate_1, &[]),
+            (&ix_allocate_2, &[]),
+            (&ix_assign_1, &[]),
+            (&ix_assign_2, &[]),
+            (&ix_write_data_to_1, &[]),
+            (&ix_write_data_to_2, &[]),
+            (
+                &ix_close_1,
+                // Just check the final result.
+                &[
+                    Check::success(),
+                    Check::account(&target1).closed().build(),
+                    Check::account(&target2)
+                        .data(data)
+                        .lamports(lamports)
+                        .owner(&program_id)
+                        .build(),
+                ],
+            ),
         ],
         &[
             (payer, system_account_with_lamports(lamports * 4)),
@@ -134,14 +185,5 @@ fn test_mixed() {
             (incinerator::id(), Account::default()),
             keyed_account_for_system_program(),
         ],
-        &[
-            Check::success(),
-            Check::account(&target1).closed().build(),
-            Check::account(&target2)
-                .data(data)
-                .lamports(lamports)
-                .owner(&program_id)
-                .build(),
-        ],
     );
 }

scripts/prepublish.sh

@@ -1,5 +1,7 @@
 #!/bin/bash
 
+set -e
+
 agave-install init 2.1.0
 rm -rf target
 cargo build