harness: add support for precompiles (#69)

Author: buffalojoec

Cargo.lock

@@ -22,6 +22,8 @@ version = "0.0.12"
 bincode = "1.3.3"
 bs58 = "0.5.1"
 criterion = "0.5.1"
+ed25519-dalek = "=1.0.1"
+libsecp256k1 = "0.6.0"
 mollusk-svm = { path = "harness", version = "0.0.12" }
 mollusk-svm-bencher = { path = "bencher", version = "0.0.12" }
 mollusk-svm-error = { path = "error", version = "0.0.12" }
@@ -35,6 +37,7 @@ num-format = "0.4.4"
 prost = "0.10"
 prost-build = "0.10"
 prost-types = "0.10"
+rand0-7 = { package = "rand", version = "0.7" }
 rayon = "1.10.0"
 serde = "1.0.203"
 serde_json = "1.0.117"

Cargo.toml

@@ -37,6 +37,9 @@ solana-timings = { workspace = true }
 
 [dev-dependencies]
 criterion = { workspace = true }
+ed25519-dalek = { workspace = true }
+libsecp256k1 = { workspace = true }
+rand0-7 = { workspace = true }
 rayon = { workspace = true }
 serial_test = { workspace = true }
 

harness/Cargo.toml

@@ -47,8 +47,8 @@ use {
     solana_program_runtime::invoke_context::{EnvironmentConfig, InvokeContext},
     solana_sdk::{
         account::AccountSharedData, bpf_loader_upgradeable, feature_set::FeatureSet,
-        fee::FeeStructure, hash::Hash, instruction::Instruction, pubkey::Pubkey,
-        transaction_context::TransactionContext,
+        fee::FeeStructure, hash::Hash, instruction::Instruction, precompiles::get_precompile,
+        pubkey::Pubkey, transaction_context::TransactionContext,
     },
     solana_timings::ExecuteTimings,
     std::sync::Arc,
@@ -156,11 +156,15 @@ impl Mollusk {
         let mut compute_units_consumed = 0;
         let mut timings = ExecuteTimings::default();
 
-        let loader_key = self
-            .program_cache
-            .load_program(&instruction.program_id)
-            .or_panic_with(MolluskError::ProgramNotCached(&instruction.program_id))
-            .account_owner();
+        let loader_key = if crate::program::precompile_keys::is_precompile(&instruction.program_id)
+        {
+            crate::program::loader_keys::NATIVE_LOADER
+        } else {
+            self.program_cache
+                .load_program(&instruction.program_id)
+                .or_panic_with(MolluskError::ProgramNotCached(&instruction.program_id))
+                .account_owner()
+        };
 
         let CompiledAccounts {
             program_id_index,
@@ -178,7 +182,7 @@ impl Mollusk {
         let invoke_result = {
             let mut program_cache = self.program_cache.cache().write().unwrap();
             let sysvar_cache = self.sysvars.setup_sysvar_cache(accounts);
-            InvokeContext::new(
+            let mut invoke_context = InvokeContext::new(
                 &mut transaction_context,
                 &mut program_cache,
                 EnvironmentConfig::new(
@@ -191,14 +195,26 @@ impl Mollusk {
                 ),
                 None,
                 self.compute_budget,
-            )
-            .process_instruction(
-                &instruction.data,
-                &instruction_accounts,
-                &[program_id_index],
-                &mut compute_units_consumed,
-                &mut timings,
-            )
+            );
+            if let Some(precompile) = get_precompile(&instruction.program_id, |feature_id| {
+                invoke_context.get_feature_set().is_active(feature_id)
+            }) {
+                invoke_context.process_precompile(
+                    precompile,
+                    &instruction.data,
+                    &instruction_accounts,
+                    &[program_id_index],
+                    std::iter::once(instruction.data.as_ref()),
+                )
+            } else {
+                invoke_context.process_instruction(
+                    &instruction.data,
+                    &instruction_accounts,
+                    &[program_id_index],
+                    &mut compute_units_consumed,
+                    &mut timings,
+                )
+            }
         };
 
         let resulting_accounts: Vec<(Pubkey, AccountSharedData)> = accounts

harness/src/lib.rs

@@ -27,6 +27,23 @@ pub mod loader_keys {
     };
 }
 
+pub mod precompile_keys {
+    use solana_sdk::pubkey::Pubkey;
+    pub use solana_sdk::{
+        ed25519_program::ID as ED25519_PROGRAM,
+        secp256k1_program::ID as SECP256K1_PROGRAM,
+        // secp256r1_program::ID as SECP256R1_PROGRAM, // Add me when patch version for 2.1 is
+        // advanced!
+    };
+
+    pub(crate) fn is_precompile(program_id: &Pubkey) -> bool {
+        matches!(
+            *program_id,
+            ED25519_PROGRAM | SECP256K1_PROGRAM /* | SECP256R1_PROGRAM */ // Add me when patch version for 2.1 is advanced!
+        )
+    }
+}
+
 pub struct ProgramCache {
     cache: RwLock<ProgramCacheForTxBatch>,
 }

harness/src/program.rs

@@ -0,0 +1,53 @@
+use {
+    mollusk_svm::{result::Check, Mollusk},
+    rand0_7::thread_rng,
+    solana_sdk::{
+        account::{AccountSharedData, WritableAccount},
+        ed25519_instruction::new_ed25519_instruction,
+        ed25519_program, native_loader,
+        pubkey::Pubkey,
+        secp256k1_instruction::new_secp256k1_instruction,
+        secp256k1_program,
+    },
+};
+
+fn precompile_account() -> AccountSharedData {
+    let mut account = AccountSharedData::new(1, 0, &native_loader::id());
+    account.set_executable(true);
+    account
+}
+
+#[test]
+fn test_secp256k1() {
+    let mollusk = Mollusk::default();
+    let secret_key = libsecp256k1::SecretKey::random(&mut thread_rng());
+
+    mollusk.process_and_validate_instruction(
+        &new_secp256k1_instruction(&secret_key, b"hello"),
+        &[
+            (Pubkey::new_unique(), AccountSharedData::default()),
+            (secp256k1_program::id(), precompile_account()),
+        ],
+        &[Check::success()],
+    );
+}
+
+#[test]
+fn test_ed25519() {
+    let mollusk = Mollusk::default();
+    let secret_key = ed25519_dalek::Keypair::generate(&mut thread_rng());
+
+    mollusk.process_and_validate_instruction(
+        &new_ed25519_instruction(&secret_key, b"hello"),
+        &[
+            (Pubkey::new_unique(), AccountSharedData::default()),
+            (ed25519_program::id(), precompile_account()),
+        ],
+        &[Check::success()],
+    );
+}
+
+#[test]
+fn test_secp256r1() {
+    // Add me when patch version for 2.1 is advanced!
+}