harness: use Message to compile accounts (#189)

Author: buffalojoec

Cargo.lock

@@ -5,7 +5,6 @@ members = [
     "error",
     "fuzz/*",
     "harness",
-    "keys",
     "programs/*",
     "result",
     "test-programs/*",
@@ -39,7 +38,6 @@ mollusk-svm-error = { path = "error", version = "0.8.1" }
 mollusk-svm-fuzz-fixture = { path = "fuzz/fixture", version = "0.8.1" }
 mollusk-svm-fuzz-fixture-firedancer = { path = "fuzz/fixture-fd", version = "0.8.1" }
 mollusk-svm-fuzz-fs = { path = "fuzz/fs", version = "0.8.1" }
-mollusk-svm-keys = { path = "keys", version = "0.8.1" }
 mollusk-svm-programs-memo = { path = "programs/memo", version = "0.8.1" }
 mollusk-svm-result = { path = "result", version = "0.8.1" }
 mollusk-svm-programs-token = { path = "programs/token", version = "0.8.1" }
@@ -90,6 +88,7 @@ solana-stake-interface = "2.0.1"
 solana-svm-callback = "3.1.0"
 solana-svm-log-collector = "3.1.0"
 solana-svm-timings = "3.1.0"
+solana-svm-transaction = "3.0.0"
 solana-system-interface = "2.0"
 solana-system-program = "3.1.0"
 solana-sysvar = "3.0"

Cargo.toml

@@ -49,7 +49,6 @@ publish:
 	@set -e && set -u && set -o pipefail && \
 	CRATES=( \
 		"mollusk-svm-error" \
-		"mollusk-svm-keys" \
 		"mollusk-svm-fuzz-fs" \
 		"mollusk-svm-fuzz-fixture" \
 		"mollusk-svm-fuzz-fixture-firedancer" \

Makefile

@@ -27,7 +27,6 @@ fuzz-fd = [
 ]
 inner-instructions = [
     "mollusk-svm-result/inner-instructions",
-    "dep:solana-message",
     "dep:solana-transaction-status-client-types",
 ]
 invocation-inspect-callback = []
@@ -53,7 +52,6 @@ mollusk-svm-error = { workspace = true }
 mollusk-svm-fuzz-fixture = { workspace = true, optional = true }
 mollusk-svm-fuzz-fixture-firedancer = { workspace = true, optional = true }
 mollusk-svm-fuzz-fs = { workspace = true, optional = true }
-mollusk-svm-keys = { workspace = true }
 mollusk-svm-result = { workspace = true }
 sha2 = { workspace = true, optional = true }
 solana-account = { workspace = true }
@@ -70,7 +68,7 @@ solana-loader-v3-interface = { workspace = true, features = ["serde"] }
 solana-loader-v4-interface = { workspace = true }
 solana-loader-v4-program = { workspace = true, features = ["agave-unstable-api"], optional = true }
 solana-logger = { workspace = true }
-solana-message = { workspace = true, optional = true }
+solana-message = { workspace = true }
 solana-precompile-error = { workspace = true }
 solana-program-error = { workspace = true }
 solana-program-runtime = { workspace = true }
@@ -82,6 +80,7 @@ solana-stake-interface = { workspace = true }
 solana-svm-callback = { workspace = true }
 solana-svm-log-collector = { workspace = true }
 solana-svm-timings = { workspace = true }
+solana-svm-transaction = { workspace = true }
 solana-system-program = { workspace = true, features = ["agave-unstable-api"] }
 solana-sysvar = { workspace = true }
 solana-sysvar-id = { workspace = true }

harness/Cargo.toml

@@ -2,39 +2,82 @@
 //! privilege handling, and program account stubbing.
 
 use {
-    mollusk_svm_keys::{
-        accounts::{
-            compile_instruction_accounts, compile_instruction_without_data,
-            compile_transaction_accounts,
-        },
-        keys::KeyMap,
-    },
-    solana_account::{Account, AccountSharedData},
+    mollusk_svm_error::error::{MolluskError, MolluskPanic},
+    solana_account::{Account, AccountSharedData, WritableAccount},
     solana_instruction::Instruction,
+    solana_message::{LegacyMessage, Message, SanitizedMessage},
     solana_pubkey::Pubkey,
-    solana_transaction_context::InstructionAccount,
-    std::collections::HashMap,
+    std::collections::{HashMap, HashSet},
 };
 
-pub struct CompiledAccounts {
-    pub program_id_index: u16,
-    pub instruction_accounts: Vec<InstructionAccount>,
-    pub transaction_accounts: Vec<(Pubkey, AccountSharedData)>,
-}
-
 pub fn compile_accounts<'a>(
     instruction: &Instruction,
     accounts: impl Iterator<Item = &'a (Pubkey, Account)>,
     fallback_accounts: &HashMap<Pubkey, Account>,
-) -> CompiledAccounts {
-    let key_map = KeyMap::compile_from_instruction(instruction);
-    let compiled_instruction = compile_instruction_without_data(&key_map, instruction);
-    let instruction_accounts = compile_instruction_accounts(&key_map, &compiled_instruction);
-    let transaction_accounts = compile_transaction_accounts(&key_map, accounts, fallback_accounts);
-
-    CompiledAccounts {
-        program_id_index: compiled_instruction.program_id_index as u16,
-        instruction_accounts,
-        transaction_accounts,
-    }
+) -> (SanitizedMessage, Vec<(Pubkey, AccountSharedData)>) {
+    let message = Message::new(std::slice::from_ref(instruction), None);
+    let sanitized_message = SanitizedMessage::Legacy(LegacyMessage::new(message, &HashSet::new()));
+
+    let accounts: Vec<_> = accounts.collect();
+    let transaction_accounts = build_transaction_accounts(
+        &sanitized_message,
+        instruction.program_id,
+        &accounts,
+        std::slice::from_ref(instruction),
+        fallback_accounts,
+    );
+
+    (sanitized_message, transaction_accounts)
+}
+
+fn build_transaction_accounts(
+    message: &SanitizedMessage,
+    program_id: Pubkey,
+    accounts: &[&(Pubkey, Account)],
+    all_instructions: &[Instruction],
+    fallback_accounts: &HashMap<Pubkey, Account>,
+) -> Vec<(Pubkey, AccountSharedData)> {
+    message
+        .account_keys()
+        .iter()
+        .map(|key| {
+            if *key == program_id {
+                if let Some(provided_account) = accounts.iter().find(|(k, _)| k == key) {
+                    return (*key, AccountSharedData::from(provided_account.1.clone()));
+                }
+                if let Some(fallback) = fallback_accounts.get(key) {
+                    return (*key, AccountSharedData::from(fallback.clone()));
+                }
+                // This shouldn't happen if fallbacks are set up correctly.
+                let mut program_account = Account::default();
+                program_account.set_executable(true);
+                return (*key, program_account.into());
+            }
+
+            if *key == solana_instructions_sysvar::ID {
+                if let Some((_, provided_account)) = accounts.iter().find(|(k, _)| k == key) {
+                    return (*key, AccountSharedData::from(provided_account.clone()));
+                }
+                if let Some(fallback) = fallback_accounts.get(key) {
+                    return (*key, AccountSharedData::from(fallback.clone()));
+                }
+                let (_, account) =
+                    crate::instructions_sysvar::keyed_account(all_instructions.iter());
+                return (*key, account.into());
+            }
+
+            let account = accounts
+                .iter()
+                .find(|(k, _)| k == key)
+                .map(|(_, a)| AccountSharedData::from(a.clone()))
+                .or_else(|| {
+                    fallback_accounts
+                        .get(key)
+                        .map(|a| AccountSharedData::from(a.clone()))
+                })
+                .or_panic_with(MolluskError::AccountMissing(key));
+
+            (*key, account)
+        })
+        .collect()
 }

harness/src/compile_accounts.rs

@@ -5,10 +5,7 @@
 //! Only available when the `fuzz-fd` feature is enabled.
 
 use {
-    crate::{
-        compile_accounts::{compile_accounts, CompiledAccounts},
-        Mollusk, DEFAULT_LOADER_KEY,
-    },
+    crate::{compile_accounts::compile_accounts, Mollusk, DEFAULT_LOADER_KEY},
     agave_feature_set::FeatureSet,
     mollusk_svm_fuzz_fixture_firedancer::{
         context::{
@@ -24,6 +21,8 @@ use {
     solana_compute_budget::compute_budget::ComputeBudget,
     solana_instruction::{error::InstructionError, AccountMeta, Instruction},
     solana_pubkey::Pubkey,
+    solana_transaction_context::InstructionAccount,
+    std::collections::HashMap,
 };
 
 static BUILTIN_PROGRAM_IDS: &[Pubkey] = &[
@@ -69,7 +68,7 @@ fn build_fixture_context(
         DEFAULT_LOADER_KEY
     };
 
-    let fallbacks = [(
+    let fallbacks: HashMap<Pubkey, Account> = [(
         instruction.program_id,
         Account {
             owner: loader_key,
@@ -80,11 +79,22 @@ fn build_fixture_context(
     .into_iter()
     .collect();
 
-    let CompiledAccounts {
-        instruction_accounts,
-        transaction_accounts,
-        ..
-    } = compile_accounts(instruction, accounts.iter(), &fallbacks);
+    let (sanitized_message, transaction_accounts) =
+        compile_accounts(instruction, accounts.iter(), &fallbacks);
+
+    let compiled_ix = sanitized_message.instructions().first().unwrap();
+    let instruction_accounts: Vec<InstructionAccount> = compiled_ix
+        .accounts
+        .iter()
+        .map(|&index_in_transaction| {
+            let index = index_in_transaction as usize;
+            InstructionAccount::new(
+                index_in_transaction as u16,
+                sanitized_message.is_signer(index),
+                sanitized_message.is_writable(index),
+            )
+        })
+        .collect();
 
     let accounts = transaction_accounts
         .into_iter()
@@ -238,6 +248,8 @@ pub(crate) fn parse_fixture_effects(
         resulting_accounts,
         #[cfg(feature = "inner-instructions")]
         inner_instructions: vec![],
+        #[cfg(feature = "inner-instructions")]
+        message: None,
     }
 }