Compile contract artifacts in test targets (#1585)

- **Refactor starknet-contract compiler**
- **Emit starknet contracts in test targets**

scarb/src/compiler/compilers/starknet_contract/artifacts_writer.rs

@@ -0,0 +1,167 @@
+use crate::compiler::compilers::starknet_contract::{ContractFileStemCalculator, ContractSelector};
+use crate::compiler::compilers::Props;
+use crate::compiler::helpers::write_json;
+use crate::core::{PackageName, Workspace};
+use crate::flock::Filesystem;
+use cairo_lang_compiler::db::RootDatabase;
+use cairo_lang_defs::ids::NamedLanguageElementId;
+use cairo_lang_starknet::contract::ContractDeclaration;
+use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
+use cairo_lang_starknet_classes::contract_class::ContractClass;
+use cairo_lang_utils::UpcastMut;
+use itertools::{izip, Itertools};
+use scarb_stable_hash::short_hash;
+use serde::Serialize;
+use smol_str::SmolStr;
+
+#[derive(Debug, Serialize)]
+struct StarknetArtifacts {
+ version: usize,
+ contracts: Vec<ContractArtifacts>,
+}
+
+impl Default for StarknetArtifacts {
+ fn default() -> Self {
+ Self {
+ version: 1,
+ contracts: Vec::new(),
+ }
+ }
+}
+
+impl StarknetArtifacts {
+ fn finish(&mut self) {
+ assert!(
+ self.contracts.iter().map(|it| &it.id).all_unique(),
+ "Artifacts IDs must be unique."
+ );
+
+ self.contracts.sort_unstable_by_key(|it| it.id.clone());
+ }
+}
+
+#[derive(Debug, Serialize)]
+struct ContractArtifacts {
+ id: String,
+ package_name: PackageName,
+ contract_name: String,
+ module_path: String,
+ artifacts: ContractArtifact,
+}
+
+impl ContractArtifacts {
+ fn new(
+ package_name: PackageName,
+ contract_name: &str,
+ contract_path: &str,
+ module_path: &str,
+ ) -> Self {
+ Self {
+ id: short_hash((&package_name, &contract_path)),
+ package_name,
+ contract_name: contract_name.to_owned(),
+ module_path: module_path.to_owned(),
+ artifacts: ContractArtifact::default(),
+ }
+ }
+}
+
+#[derive(Debug, Default, Serialize)]
+struct ContractArtifact {
+ sierra: Option<String>,
+ casm: Option<String>,
+}
+
+pub struct ArtifactsWriter {
+ sierra: bool,
+ casm: bool,
+ target_dir: Filesystem,
+ target_name: SmolStr,
+ extension_prefix: Option<String>,
+}
+
+impl ArtifactsWriter {
+ pub fn new(target_name: SmolStr, target_dir: Filesystem, props: Props) -> Self {
+ Self {
+ sierra: props.sierra,
+ casm: props.casm,
+ target_dir,
+ target_name,
+ extension_prefix: None,
+ }
+ }
+
+ pub fn with_extension_prefix(self, prefix: String) -> Self {
+ Self {
+ extension_prefix: Some(prefix),
+ ..self
+ }
+ }
+
+ pub fn write(
+ self,
+ contract_paths: Vec<String>,
+ contracts: &Vec<ContractDeclaration>,
+ classes: &[ContractClass],
+ casm_classes: &[Option<CasmContractClass>],
+ db: &mut RootDatabase,
+ ws: &Workspace<'_>,
+ ) -> anyhow::Result<()> {
+ let mut artifacts = StarknetArtifacts::default();
+ let mut file_stem_calculator = ContractFileStemCalculator::new(contract_paths);
+ let extension_prefix = self
+ .extension_prefix
+ .map(|ext| format!(".{ext}"))
+ .unwrap_or_default();
+
+ for (declaration, class, casm_class) in izip!(contracts, classes, casm_classes) {
+ let contract_name = declaration.submodule_id.name(db.upcast_mut());
+ let contract_path = declaration.module_id().full_path(db.upcast_mut());
+
+ let contract_selector = ContractSelector(contract_path);
+ let package_name = contract_selector.package();
+ let contract_stem = file_stem_calculator.get_stem(contract_selector.full_path());
+
+ let file_stem = format!("{}_{contract_stem}", self.target_name);
+
+ let mut artifact = ContractArtifacts::new(
+ package_name,
+ &contract_name,
+ contract_selector.full_path().as_str(),
+ &declaration.module_id().full_path(db.upcast_mut()),
+ );
+
+ if self.sierra {
+ let file_name = format!("{file_stem}{extension_prefix}.contract_class.json");
+ write_json(&file_name, "output file", &self.target_dir, ws, class)?;
+ artifact.artifacts.sierra = Some(file_name);
+ }
+
+ if self.casm {
+ if let Some(casm_class) = casm_class {
+ let file_name =
+ format!("{file_stem}{extension_prefix}.compiled_contract_class.json");
+ write_json(&file_name, "output file", &self.target_dir, ws, casm_class)?;
+ artifact.artifacts.casm = Some(file_name);
+ }
+ }
+
+ artifacts.contracts.push(artifact);
+ }
+
+ artifacts.finish();
+
+ write_json(
+ &format!(
+ "{}{extension_prefix}.starknet_artifacts.json",
+ self.target_name
+ ),
+ "starknet artifacts file",
+ &self.target_dir,
+ ws,
+ &artifacts,
+ )?;
+
+ Ok(())
+ }
+}