add sierra path to contracts data

crates/cheatnet/src/runtime_extensions/forge_runtime_extension/contracts_data.rs

@@ -1,6 +1,7 @@
 use super::cheatcodes::declare::get_class_hash;
 use anyhow::Result;
 use bimap::BiMap;
+use camino::Utf8PathBuf;
 use conversions::IntoConv;
 use rayon::iter::{IntoParallelIterator, IntoParallelRefIterator, ParallelIterator};
 use scarb_api::StarknetContractArtifacts;
@@ -12,13 +13,17 @@ use std::collections::HashMap;
 #[derive(Debug, Clone)]
 pub struct ContractsData {
  pub contracts: HashMap<String, StarknetContractArtifacts>,
+ pub sierra_paths: HashMap<String, Utf8PathBuf>,
  pub class_hashes: BiMap<String, ClassHash>,
  pub selectors: HashMap<EntryPointSelector, String>,
 }
 
 impl ContractsData {
- pub fn try_from(contracts: HashMap<String, StarknetContractArtifacts>) -> Result<Self> {
- let parsed_contracts: HashMap<String, SierraClass> = contracts
+ pub fn try_from(
+ contracts_artifacts: HashMap<String, StarknetContractArtifacts>,
+ contracts_sierra_paths: HashMap<String, Utf8PathBuf>,
+ ) -> Result<Self> {
+ let parsed_contracts: HashMap<String, SierraClass> = contracts_artifacts
  .par_iter()
  .map(|(name, artifact)| Ok((name.clone(), serde_json::from_str(&artifact.sierra)?)))
  .collect::<Result<_>>()?;
@@ -35,7 +40,8 @@ impl ContractsData {
  .collect();
 
  Ok(ContractsData {
- contracts,
+ contracts: contracts_artifacts,
+ sierra_paths: contracts_sierra_paths,
  class_hashes: BiMap::from_iter(class_hashes),
  selectors,
  })

crates/cheatnet/tests/common/mod.rs

@@ -24,7 +24,7 @@ use cheatnet::state::CheatnetState;
 use conversions::IntoConv;
 use runtime::starknet::context::build_context;
 use scarb_api::metadata::MetadataCommandExt;
-use scarb_api::{get_contracts_map, ScarbCommand};
+use scarb_api::{get_contracts_artifacts_and_sierra_paths, ScarbCommand};
 use starknet::core::utils::get_selector_from_name;
 use starknet_api::core::PatriciaKey;
 use starknet_api::core::{ClassHash, ContractAddress};
@@ -76,7 +76,9 @@ pub fn get_contracts() -> ContractsData {
 
  let package = scarb_metadata.packages.first().unwrap();
 
- ContractsData::try_from(get_contracts_map(&scarb_metadata, &package.id, None).unwrap()).unwrap()
+ let (contracts_artifacts, contracts_sierra_paths) =
+ get_contracts_artifacts_and_sierra_paths(&scarb_metadata, &package.id, None).unwrap();
+ ContractsData::try_from(contracts_artifacts, contracts_sierra_paths).unwrap()
 }
 
 pub fn deploy_contract(

crates/forge/src/compiled_raw.rs

@@ -4,14 +4,14 @@ use forge_runner::expected_result::ExpectedTestResult;
 use serde::Deserialize;
 
 #[derive(Debug, Clone, Deserialize)]
-pub(crate) struct CompiledTestCrateRaw {
+pub struct CompiledTestCrateRaw {
  pub sierra_program: VersionedProgram,
  pub test_cases: Vec<TestCaseRaw>,
  pub tests_location: CrateLocation,
 }
 
 #[derive(Debug, PartialEq, Clone, Deserialize)]
-pub(crate) struct TestCaseRaw {
+pub struct TestCaseRaw {
  pub name: String,
  pub available_gas: Option<usize>,
  pub ignored: bool,
@@ -22,15 +22,15 @@ pub(crate) struct TestCaseRaw {
 }
 
 #[derive(Debug, PartialEq, Clone, Copy, Deserialize)]
-pub(crate) enum CrateLocation {
+pub enum CrateLocation {
  /// Main crate in a package
  Lib,
  /// Crate in the `tests/` directory
  Tests,
 }
 
 #[derive(Debug, Clone, PartialEq, Deserialize)]
-pub(crate) enum RawForkConfig {
+pub enum RawForkConfig {
  Id(String),
  Params(RawForkParams),
 }

crates/forge/src/lib.rs

@@ -1,10 +1,8 @@
-use anyhow::{anyhow, Context, Result};
-use camino::Utf8Path;
+use anyhow::{anyhow, Result};
 use warn::{
  warn_if_available_gas_used_with_incompatible_scarb_version, warn_if_incompatible_rpc_version,
 };
 
-use crate::scarb::load_test_artifacts;
 use forge_runner::test_case_summary::AnyTestCaseSummary;
 use std::sync::Arc;
 
@@ -99,19 +97,20 @@ async fn to_runnable(
 /// * `fork_target` - A configuration of forks used in tests
 #[allow(clippy::implicit_hasher)]
 pub async fn run(
+ compiled_test_crates: Vec<CompiledTestCrateRaw>,
  package_name: &str,
- snforge_target_dir_path: &Utf8Path,
  tests_filter: &TestsFilter,
  runner_config: Arc<RunnerConfig>,
  runner_params: Arc<RunnerParams>,
  fork_targets: &[ForkTarget],
  block_number_map: &mut BlockNumberMap,
 ) -> Result<Vec<TestCrateSummary>> {
- let test_crates = load_test_artifacts(snforge_target_dir_path, package_name)
- .context("Failed to load test artifacts, make sure to use scarb >=2.5.4")?;
- let all_tests: usize = test_crates.iter().map(|tc| tc.test_cases.len()).sum();
+ let all_tests: usize = compiled_test_crates
+ .iter()
+ .map(|tc| tc.test_cases.len())
+ .sum();
 
- let test_crates = test_crates
+ let test_crates = compiled_test_crates
  .into_iter()
  .map(|tc| tests_filter.filter_tests(tc))
  .collect::<Result<Vec<CompiledTestCrateRaw>>>()?;

crates/forge/src/main.rs

@@ -3,7 +3,10 @@ use camino::Utf8Path;
 use clap::{Parser, Subcommand, ValueEnum};
 use configuration::load_package_config;
 use forge::scarb::config::ForgeConfig;
-use forge::scarb::{build_contracts_with_scarb, build_test_artifacts_with_scarb};
+use forge::scarb::{
+ build_contracts_with_scarb, build_test_artifacts_with_scarb, load_test_artifacts,
+ test_artifacts_path,
+};
 use forge::shared_cache::{clean_cache, set_cached_failed_tests_names};
 use forge::test_filter::TestsFilter;
 use forge::{pretty_printing, run};
@@ -12,7 +15,7 @@ use forge_runner::test_crate_summary::TestCrateSummary;
 use forge_runner::{RunnerConfig, RunnerParams, CACHE_DIR};
 use rand::{thread_rng, RngCore};
 use scarb_api::{
- get_contracts_map,
+ get_contracts_artifacts_and_sierra_paths,
  metadata::{Metadata, MetadataCommandExt, PackageMetadata},
  package_matches_version_requirement, target_dir_for_workspace, ScarbCommand,
 };
@@ -236,13 +239,17 @@ fn test_workspace(args: TestArgs) -> Result<bool> {
  for package in &packages {
  env::set_current_dir(&package.root)?;
 
- let forge_config =
- load_package_config::<ForgeConfig>(&scarb_metadata, &package.id)?;
- let contracts =
- get_contracts_map(&scarb_metadata, &package.id, None).unwrap_or_default();
+ let test_artifacts_path =
+ test_artifacts_path(&snforge_target_dir_path, &package.name);
+ let compiled_test_crates = load_test_artifacts(&test_artifacts_path)?;
 
- let contracts_data = ContractsData::try_from(contracts)?;
+ let (contracts_artifacts, contracts_sierra_paths) =
+ get_contracts_artifacts_and_sierra_paths(&scarb_metadata, &package.id, None)?;
+ let contracts_data =
+ ContractsData::try_from(contracts_artifacts, contracts_sierra_paths)?;
 
+ let forge_config =
+ load_package_config::<ForgeConfig>(&scarb_metadata, &package.id)?;
  let runner_config = Arc::new(combine_configs(
  &workspace_root,
  args.exit_first,
@@ -258,8 +265,8 @@ fn test_workspace(args: TestArgs) -> Result<bool> {
  Arc::new(RunnerParams::new(contracts_data, env::vars().collect()));
 
  let tests_file_summaries = run(
+ compiled_test_crates,
  &package.name,
- &snforge_target_dir_path,
  &TestsFilter::from_flags(
  args.test_filter.clone(),
  args.exact,

crates/forge/src/scarb.rs

@@ -1,7 +1,7 @@
 use crate::compiled_raw::CompiledTestCrateRaw;
 use crate::scarb::config::{ForgeConfig, RawForgeConfig};
 use anyhow::{Context, Result};
-use camino::Utf8Path;
+use camino::{Utf8Path, Utf8PathBuf};
 use configuration::PackageConfig;
 use scarb_api::ScarbCommand;
 use scarb_ui::args::PackagesFilter;
@@ -43,16 +43,15 @@ pub fn build_test_artifacts_with_scarb(filter: PackagesFilter) -> Result<()> {
  Ok(())
 }
 
-pub(crate) fn load_test_artifacts(
- snforge_target_dir_path: &Utf8Path,
- package_name: &str,
-) -> Result<Vec<CompiledTestCrateRaw>> {
- let snforge_test_artifact_path =
- snforge_target_dir_path.join(format!("{package_name}.snforge_sierra.json"));
- let test_crates = serde_json::from_str::<Vec<CompiledTestCrateRaw>>(&std::fs::read_to_string(
- snforge_test_artifact_path,
- )?)?;
- Ok(test_crates)
+#[must_use]
+pub fn test_artifacts_path(snforge_target_dir_path: &Utf8Path, package_name: &str) -> Utf8PathBuf {
+ snforge_target_dir_path.join(format!("{package_name}.snforge_sierra.json"))
+}
+
+pub fn load_test_artifacts(test_artifacts_path: &Utf8PathBuf) -> Result<Vec<CompiledTestCrateRaw>> {
+ Ok(serde_json::from_str::<Vec<CompiledTestCrateRaw>>(
+ &std::fs::read_to_string(test_artifacts_path)?,
+ )?)
 }
 
 #[cfg(test)]

crates/forge/test_utils/src/runner.rs

@@ -12,7 +12,8 @@ use forge_runner::{
 };
 use indoc::formatdoc;
 use scarb_api::{
- get_contracts_map, metadata::MetadataCommandExt, ScarbCommand, StarknetContractArtifacts,
+ get_contracts_artifacts_and_sierra_paths, metadata::MetadataCommandExt, ScarbCommand,
+ StarknetContractArtifacts,
 };
 use shared::command::CommandExt;
 use std::{
@@ -95,8 +96,9 @@ impl Contract {
  .find(|package| package.name == "contract")
  .unwrap();
 
- let contract = get_contracts_map(&scarb_metadata, &package.id, None)
+ let contract = get_contracts_artifacts_and_sierra_paths(&scarb_metadata, &package.id, None)
  .unwrap()
+ .0
  .remove(&self.name)
  .ok_or(anyhow!("there is no contract with name {}", self.name))?;
 

crates/forge/test_utils/src/running_tests.rs

@@ -3,10 +3,12 @@ use camino::Utf8PathBuf;
 use cheatnet::runtime_extensions::forge_runtime_extension::contracts_data::ContractsData;
 use forge::block_number_map::BlockNumberMap;
 use forge::run;
+use forge::scarb::{load_test_artifacts, test_artifacts_path};
 use forge::test_filter::TestsFilter;
 use forge_runner::test_crate_summary::TestCrateSummary;
 use forge_runner::{RunnerConfig, RunnerParams};
 use shared::command::CommandExt;
+use std::collections::HashMap;
 use std::num::NonZeroU32;
 use std::path::PathBuf;
 use std::process::Command;
@@ -26,10 +28,15 @@ pub fn run_test_case(test: &TestCase) -> Vec<TestCrateSummary> {
  .unwrap();
 
  let rt = Runtime::new().expect("Could not instantiate Runtime");
+ let test_artifacts_path = test_artifacts_path(
+ &test.path().unwrap().join("target/dev/snforge"),
+ "test_package",
+ );
+ let compiled_test_crates = load_test_artifacts(&test_artifacts_path).unwrap();
 
  rt.block_on(run(
+ compiled_test_crates,
  "test_package",
- &test.path().unwrap().join("target/dev/snforge"),
  &TestsFilter::from_flags(None, false, false, false, false, Default::default()),
  Arc::new(RunnerConfig::new(
  Utf8PathBuf::from_path_buf(PathBuf::from(tempdir().unwrap().path())).unwrap(),
@@ -42,7 +49,7 @@ pub fn run_test_case(test: &TestCase) -> Vec<TestCrateSummary> {
  None,
  )),
  Arc::new(RunnerParams::new(
- ContractsData::try_from(test.contracts().unwrap()).unwrap(),
+ ContractsData::try_from(test.contracts().unwrap(), HashMap::new()).unwrap(),
  test.env().clone(),
  )),
  &[],

crates/forge/tests/integration/setup_fork.rs

@@ -1,4 +1,5 @@
 use indoc::formatdoc;
+use std::collections::HashMap;
 use std::path::Path;
 use std::path::PathBuf;
 use std::process::Command;
@@ -15,6 +16,7 @@ use tokio::runtime::Runtime;
 
 use cheatnet::runtime_extensions::forge_runtime_extension::contracts_data::ContractsData;
 use forge::compiled_raw::RawForkParams;
+use forge::scarb::{load_test_artifacts, test_artifacts_path};
 use forge_runner::{RunnerConfig, RunnerParams};
 use shared::command::CommandExt;
 use test_utils::runner::{assert_case_output_contains, assert_failed, assert_passed, Contract};
@@ -112,10 +114,16 @@ fn fork_aliased_decorator() {
  .output_checked()
  .unwrap();
 
+ let test_artifacts_path = test_artifacts_path(
+ &test.path().unwrap().join("target/dev/snforge"),
+ "test_package",
+ );
+ let compiled_test_crates = load_test_artifacts(&test_artifacts_path).unwrap();
+
  let result = rt
  .block_on(run(
- &String::from("test_package"),
- &test.path().unwrap().join("target/dev/snforge"),
+ compiled_test_crates,
+ "test_package",
  &TestsFilter::from_flags(None, false, false, false, false, Default::default()),
  Arc::new(RunnerConfig::new(
  Utf8PathBuf::from_path_buf(PathBuf::from(tempdir().unwrap().path())).unwrap(),
@@ -128,7 +136,7 @@ fn fork_aliased_decorator() {
  None,
  )),
  Arc::new(RunnerParams::new(
- ContractsData::try_from(test.contracts().unwrap()).unwrap(),
+ ContractsData::try_from(test.contracts().unwrap(), HashMap::new()).unwrap(),
  test.env().clone(),
  )),
  &[ForkTarget::new(

crates/scarb-api/src/lib.rs

@@ -113,11 +113,14 @@ fn try_get_starknet_artifacts_path(
 }
 
 /// Get the map with `StarknetContractArtifacts` for the given package
-pub fn get_contracts_map(
+pub fn get_contracts_artifacts_and_sierra_paths(
  metadata: &Metadata,
  package: &PackageId,
  profile: Option<&str>,
-) -> Result<HashMap<String, StarknetContractArtifacts>> {
+) -> Result<(
+ HashMap<String, StarknetContractArtifacts>,
+ HashMap<String, Utf8PathBuf>,
+)> {
  let target_name = target_name_for_package(metadata, package)?;
  let target_dir = target_dir_for_workspace(metadata);
  let maybe_contracts_path = try_get_starknet_artifacts_path(
@@ -126,29 +129,37 @@ pub fn get_contracts_map(
  profile.unwrap_or(metadata.current_profile.as_str()),
  )?;
 
- let map = match maybe_contracts_path {
- Some(contracts_path) => load_contract_artifacts(&contracts_path)?,
- None => HashMap::default(),
+ let maps = match maybe_contracts_path {
+ Some(contracts_path) => load_contracts_artifacts_and_sierra_paths(&contracts_path)?,
+ None => (HashMap::default(), HashMap::default()),
  };
- Ok(map)
+
+ Ok(maps)
 }
 
-fn load_contract_artifacts(
+fn load_contracts_artifacts_and_sierra_paths(
  contracts_path: &Utf8PathBuf,
-) -> Result<HashMap<String, StarknetContractArtifacts>> {
+) -> Result<(
+ HashMap<String, StarknetContractArtifacts>,
+ HashMap<String, Utf8PathBuf>,
+)> {
  let base_path = contracts_path
  .parent()
  .ok_or_else(|| anyhow!("Failed to get parent for path = {}", &contracts_path))?;
  let artifacts = artifacts_for_package(contracts_path)?;
- let mut map = HashMap::new();
+ let mut artifacts_map = HashMap::new();
+ let mut sierra_paths_map = HashMap::new();
 
  for ref contract in artifacts.contracts {
  let name = contract.contract_name.clone();
  let contract_artifacts =
  StarknetContractArtifacts::from_scarb_contract_artifact(contract, base_path)?;
- map.insert(name, contract_artifacts);
+ artifacts_map.insert(name.clone(), contract_artifacts);
+
+ let sierra_path = base_path.join(contract.artifacts.sierra.clone());
+ sierra_paths_map.insert(name, sierra_path);
  }
- Ok(map)
+ Ok((artifacts_map, sierra_paths_map))
 }
 
 fn compilation_unit_for_package<'a>(
@@ -489,7 +500,9 @@ mod tests {
  .unwrap();
 
  let package = metadata.packages.first().unwrap();
- let contracts = get_contracts_map(&metadata, &package.id, None).unwrap();
+ let contracts = get_contracts_artifacts_and_sierra_paths(&metadata, &package.id, None)
+ .unwrap()
+ .0;
 
  assert!(contracts.contains_key("ERC20"));
  assert!(contracts.contains_key("HelloStarknet"));