[DRAFT] add casm json target

scarb/Cargo.toml

@@ -16,6 +16,7 @@ repository.workspace = true
 [dependencies]
 anyhow.workspace = true
 async-trait.workspace = true
+cairo-lang-casm.workspace = true
 cairo-lang-compiler.workspace = true
 cairo-lang-defs.workspace = true
 cairo-lang-diagnostics.workspace = true

scarb/src/compiler/compilers/lib.rs

@@ -1,8 +1,10 @@
 use anyhow::{Context, Result};
 use cairo_lang_compiler::db::RootDatabase;
+use cairo_lang_casm::hints::Hint;
 use cairo_lang_sierra::program::VersionedProgram;
 use cairo_lang_sierra_to_casm::compiler::SierraToCasmConfig;
 use cairo_lang_sierra_to_casm::metadata::{calc_metadata, calc_metadata_ap_change_only};
+use cairo_lang_utils::bigint::BigIntAsHex;
 use serde::{Deserialize, Serialize};
 use tracing::{debug, trace_span};
 
@@ -20,14 +22,16 @@ struct Props {
     pub sierra: bool,
     pub casm: bool,
     pub sierra_text: bool,
+    pub casm_text: bool,
 }
 
 impl Default for Props {
     fn default() -> Self {
         Self {
             sierra: true,
-            casm: false,
+            casm: true,
             sierra_text: false,
+            casm_text: false,
         }
     }
 }
@@ -44,9 +48,9 @@ impl Compiler for LibCompiler {
         ws: &Workspace<'_>,
     ) -> Result<()> {
         let props: Props = unit.target().props()?;
-        if !props.sierra && !props.casm && !props.sierra_text {
+        if !props.sierra && !props.casm && !props.sierra_text && !props.casm_text {
             ws.config().ui().warn(
-                "Sierra, textual Sierra and CASM lib targets have been disabled, \
+                "Sierra, textual Sierra, CASM and textual CASM lib targets have been disabled, \
                 Scarb will not produce anything",
             );
         }
@@ -89,32 +93,50 @@ impl Compiler for LibCompiler {
                 &sierra_program,
             )?;
         }
+        let program = sierra_program.into_v1().unwrap().program;
+        let metadata = {
+            let _ = trace_span!("casm_calc_metadata").enter();
+
+            if unit.compiler_config.enable_gas {
+                debug!("calculating Sierra variables");
+                calc_metadata(&program, Default::default())
+            } else {
+                debug!("calculating Sierra variables with no gas validation");
+                calc_metadata_ap_change_only(&program)
+            }
+            .context("failed calculating Sierra variables")?
+        };
 
-        if props.casm {
-            let program = sierra_program.into_v1().unwrap().program;
-
-            let metadata = {
-                let _ = trace_span!("casm_calc_metadata").enter();
-
-                if unit.compiler_config.enable_gas {
-                    debug!("calculating Sierra variables");
-                    calc_metadata(&program, Default::default())
-                } else {
-                    debug!("calculating Sierra variables with no gas validation");
-                    calc_metadata_ap_change_only(&program)
-                }
-                .context("failed calculating Sierra variables")?
+        let cairo_program = {
+            let _ = trace_span!("compile_casm").enter();
+            let sierra_to_casm = SierraToCasmConfig {
+                gas_usage_check: unit.compiler_config.enable_gas,
+                max_bytecode_size: usize::MAX,
             };
+            cairo_lang_sierra_to_casm::compiler::compile(&program, &metadata, sierra_to_casm)?
+        };
 
-            let cairo_program = {
-                let _ = trace_span!("compile_casm").enter();
-                let sierra_to_casm = SierraToCasmConfig {
-                    gas_usage_check: unit.compiler_config.enable_gas,
-                    max_bytecode_size: usize::MAX,
-                };
-                cairo_lang_sierra_to_casm::compiler::compile(&program, &metadata, sierra_to_casm)?
+        if props.casm {
+            let assembled_cairo_program = cairo_program.assemble();
+            let bytecode = assembled_cairo_program.bytecode.iter().map(|x| BigIntAsHex{ value: x.to_owned() }).collect::<Vec<BigIntAsHex>>();
+            let hints = assembled_cairo_program.hints;
+            let casm_program = SerializedCasm {
+                bytecode,
+                hints,
             };
+            write_json(
+                format!("{}.casm.json", unit.target().name).as_str(),
+                "output file",
+                &target_dir,
+                ws,
+                &casm_program,
+            )
+            .with_context(|| {
+                format!("failed to serialize CASM program {}", unit.target().name)
+            })?;
+        }
 
+        if props.casm_text {
             write_string(
                 format!("{}.casm", unit.target().name).as_str(),
                 "output file",
@@ -127,3 +149,16 @@ impl Compiler for LibCompiler {
         Ok(())
     }
 }
+
+/// Represents a contract in the Starknet network.
+#[derive(Clone, Default, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct SerializedCasm {
+    // #[serde(serialize_with = "serialize_big_uint", deserialize_with = "deserialize_big_uint")]
+    // pub prime: BigUint,
+    // pub compiler_version: String,
+    pub bytecode: Vec<BigIntAsHex>,
+    // #[serde(skip_serializing_if = "skip_if_none")]
+    // pub bytecode_segment_lengths: Option<NestedIntList>,
+    pub hints: Vec<(usize, Vec<Hint>)>,
+    // pub entry_points_by_type: CasmContractEntryPoints,
+}

scarb/src/core/manifest/toml_manifest.rs

@@ -291,6 +291,7 @@ pub struct TomlLibTargetParams {
     pub sierra: Option<bool>,
     pub casm: Option<bool>,
     pub sierra_text: Option<bool>,
+    pub casm_text: Option<bool>,
 }
 
 pub type TomlExternalTargetParams = BTreeMap<SmolStr, toml::Value>;

scarb/tests/build_targets.rs

@@ -88,6 +88,7 @@ fn compile_with_custom_lib_target() {
             sierra = false
             casm = true
             sierra-text = true
+            casm-text = true
             "#,
         )
         .unwrap();
@@ -104,15 +105,19 @@ fn compile_with_custom_lib_target() {
         [..] Compiling hello v0.1.0 ([..])
         [..]  Finished release target(s) in [..]
         "#});
-
-    t.child("target/dev/not_hello.casm")
+
+    t.child("target/dev/not_hello.sierra.json")
+        .assert(predicates::path::exists().not());
+    t.child("target/dev/not_hello.casm.json")
         .assert(predicates::str::is_empty().not());
     t.child("target/dev/not_hello.sierra")
         .assert(predicates::str::is_empty().not());
-    t.child("target/dev/not_hello.sierra.json")
-        .assert(predicates::path::exists().not());
+    t.child("target/dev/not_hello.casm")
+        .assert(predicates::str::is_empty().not());
     t.child("target/dev/hello.sierra.json")
         .assert(predicates::path::exists().not());
+    t.child("target/dev/hello.casm.json")
+        .assert(predicates::path::exists().not());
     t.child("target/dev/hello.casm")
         .assert(predicates::path::exists().not());
     t.child("target/dev/hello.sierra")
@@ -156,10 +161,10 @@ fn compile_with_named_default_lib_target() {
         .assert(predicates::path::exists().not());
     t.child("target/dev/hello.sierra.json")
         .assert(predicates::path::exists().not());
-    t.child("target/dev/hello.casm")
-        .assert(predicates::path::exists().not());
     t.child("target/dev/hello.sierra")
         .assert(predicates::path::exists().not());
+    t.child("target/dev/hello.casm")
+        .assert(predicates::path::exists().not());
 }
 
 #[test]