all_cov on top of litesvm master

Cargo.toml

@@ -57,6 +57,7 @@ solana-nonce = "2.2"
 solana-nonce-account = "2.2"
 solana-precompile-error = "2.2"
 solana-program-error = "2.2"
+solana-program-entrypoint = "2.3"
 solana-program-option = "2.2"
 solana-program-pack = "2.2"
 solana-program-runtime = "2.3"
@@ -89,6 +90,8 @@ spl-token-2022 = "8.0"
 test-log = "0.2"
 thiserror = "2.0"
 tokio = "1.35"
+lite-coverage = { path = "crates/lite-coverage" }
+solana-program-stubs = { version = "0.1.0", features = [ "loader_stubs" ] }
 
 [profile.bench]
 debug = true

crates/lite-coverage/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "lite-coverage"
+version = "0.1.0"
+edition = "2021"
+[lib]
+path = "src/lib.rs"
+
+[dependencies]
+libloading = "0.8.8"
+base64 = "0.22.1"
+bincode = { workspace = true }
+serde = { workspace = true }
+jsonrpc-core = "18.0.0"
+bs58 = { version = "0.5.1", default-features = false }
+borsh = "1.5.7"
+solana-program-runtime = { workspace = true }
+solana-program-test = { workspace = true }
+solana-account = { workspace = true }
+solana-keypair = { workspace = true }
+solana-signer = { workspace = true }
+solana-transaction = { workspace = true }
+solana-instruction = { workspace = true }
+solana-pubkey = { workspace = true }
+solana-program-error = { workspace = true }
+solana-program-entrypoint = { workspace = true }
+solana-sysvar = { workspace = true }
+solana-sdk-ids = { workspace = true }
+tokio = { workspace = true }
+lazy_static = "1.5.0"
+solana-program-stubs = { workspace = true }
+log.workspace = true

crates/lite-coverage/src/lib.rs

@@ -0,0 +1,7 @@
+mod lite_coverage;
+mod loader;
+mod sbf;
+mod stubs;
+mod types;
+pub use lite_coverage::*;
+pub use types::*;

crates/lite-coverage/src/lite_coverage.rs

@@ -0,0 +1,181 @@
+use std::{io::Write, rc::Rc};
+
+use solana_keypair::Keypair;
+use solana_pubkey::Pubkey;
+
+use crate::{
+    loader::{entrypoint, Loader},
+    types::{LiteCoverageError, NativeProgram},
+    AdditionalProgram, ProgramTestContextHandle,
+};
+use {
+    solana_account::AccountSharedData,
+    solana_program_test::{processor, ProgramTest, ProgramTestContext},
+    solana_transaction::versioned::VersionedTransaction,
+    std::{cell::RefCell, sync::Arc},
+    tokio::runtime::Runtime,
+};
+
+/// Main object to look after code coverage.
+#[derive(Clone)]
+pub struct LiteCoverage {
+    pub programs: Vec<NativeProgram>,
+    pub pt_context: Rc<RefCell<Option<ProgramTestContext>>>,
+    rt: Arc<Runtime>,
+    #[allow(dead_code)]
+    loader: Rc<Loader>,
+}
+
+impl LiteCoverage {
+    /// Get a singleton instance to the main code coverage object.
+    pub fn new(
+        programs: Vec<NativeProgram>,
+        additional_programs: Vec<AdditionalProgram>,
+        payer: Keypair,
+    ) -> LiteCoverageError<Self> {
+        {
+            use std::sync::Once;
+            static SINGLETON: Once = Once::new();
+
+            if !SINGLETON.is_completed() {
+                SINGLETON.call_once(|| {});
+            } else {
+                return Err(Box::<dyn std::error::Error + Send + Sync>::from(
+                    "LiteCoverage is singleton, please use only one instance of LiteSVM",
+                ));
+            }
+        }
+
+        let static_programs = Box::leak(Box::new(programs.clone()));
+        let mut program_test = ProgramTest::default();
+        program_test.prefer_bpf(false);
+        program_test.set_payer(payer);
+
+        for (pubkey, name) in additional_programs.clone().into_iter() {
+            let name = Box::leak(Box::new(name));
+            program_test.add_upgradeable_program_to_genesis(name, &pubkey);
+        }
+
+        let mut loader = Loader::new();
+        for (program_id, program_name) in static_programs.iter() {
+            log::info!(
+                "Adding native program (SBF avatar) '{}' with program id: {}",
+                program_name,
+                program_id
+            );
+            loader.add_program(program_name, program_id)?;
+            program_test.add_program(program_name, *program_id, processor!(entrypoint));
+        }
+        log::info!("Loaded: {:?}", loader);
+
+        let rt = tokio::runtime::Runtime::new()?;
+        let pt_context = rt.block_on(async move { program_test.start_with_context().await });
+        loader.adjust_stubs()?;
+
+        LiteCoverage::log_anchor_test_event_artifacts(programs.clone(), additional_programs)?;
+
+        Ok(Self {
+            pt_context: Rc::new(RefCell::new(Some(pt_context))),
+            programs,
+            rt: Arc::new(rt),
+            loader: Rc::new(loader),
+        })
+    }
+
+    /// Get a handle to the ProgramTestContext.
+    pub fn get_program_test_context(&self) -> ProgramTestContextHandle {
+        assert!(
+            self.pt_context.borrow().is_some(),
+            "ProgramTestContext is already acquired!"
+        );
+        ProgramTestContextHandle::new(Rc::clone(&self.pt_context))
+    }
+
+    /// Add an account to the ProgramTestContext.
+    pub fn add_account(&self, account_pubkey: &Pubkey, account_data: &AccountSharedData) {
+        let mut pt_context = self.get_program_test_context();
+        if let Some(ctx) = &mut *pt_context {
+            ctx.set_account(account_pubkey, account_data);
+        }
+    }
+
+    /// Register the transaction's recent blockhash into ProgramTestContext.
+    /// This avoids the need to pre-sign with payer.
+    async fn register_recent_blockhash_from_transaction(
+        &self,
+        tx: &VersionedTransaction,
+    ) -> LiteCoverageError<()> {
+        let pt_context = self.get_program_test_context();
+        let ctx = pt_context
+            .as_ref()
+            .ok_or(Box::<dyn std::error::Error + Send + Sync>::from(
+                "Missing ProgramTestContext",
+            ))?;
+
+        let trans = tx.clone().into_legacy_transaction().unwrap();
+        ctx.register_recent_blockhash(&trans.message.recent_blockhash, None);
+        Ok(())
+    }
+
+    /// Send the transaction to the natively loaded SBF avatars already prepared for
+    /// obtaining code coverage.
+    pub fn send_transaction(
+        &self,
+        tx: VersionedTransaction,
+        accounts: &[(Pubkey, AccountSharedData)],
+    ) -> LiteCoverageError<()> {
+        let _: LiteCoverageError<()> = self.rt.block_on(async {
+            for (account_pubkey, account_data) in accounts {
+                self.add_account(account_pubkey, account_data);
+            }
+            self.register_recent_blockhash_from_transaction(&tx).await?;
+
+            let pt_context = self.get_program_test_context();
+            let ctx =
+                pt_context
+                    .as_ref()
+                    .ok_or(Box::<dyn std::error::Error + Send + Sync>::from(
+                        "Missing ProgramTestContext",
+                    ))?;
+            let res = ctx
+                .banks_client
+                .process_transaction_with_metadata(tx)
+                .await?;
+
+            log::info!("LiteCoverage transaction result: {:#?}", res);
+            Ok(())
+        });
+        Ok(())
+    }
+
+    /// Log some events provided that some anchor envvars are globally set.
+    /// This is useful for anchor to know that it's litesvm that's actually used.
+    /// With this information anchor can go further visualizing the code coverage results
+    /// or bail out.
+    fn log_anchor_test_event_artifacts(
+        progs: Vec<NativeProgram>,
+        additional_progs: Vec<AdditionalProgram>,
+    ) -> LiteCoverageError<()> {
+        if let Ok(report_events) = std::env::var("ANCHOR_TEST_CODE_COVERAGE_REPORT_EVENTS") {
+            if report_events == "true" {
+                if let Ok(event_file) =
+                    std::env::var("ANCHOR_TEST_CODE_COVERAGE_ARTIFACTS_EVENT_FILE")
+                {
+                    let mut file = std::fs::OpenOptions::new()
+                        .create(true)
+                        .append(true)
+                        .write(true)
+                        .open(format!("{}.{}.log", event_file, std::process::id()))?;
+                    file.write_all("litesvm=true\n".as_bytes())?;
+                    for (pubkey, name) in &progs {
+                        file.write_all(format!("{}={}\n", name, pubkey).as_bytes())?;
+                    }
+                    for (pubkey, name) in &additional_progs {
+                        file.write_all(format!("{}={}\n", name, pubkey).as_bytes())?;
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}