starknet_os_runner: add hints to casm from contract class

Author: AvivYossef-starkware

Cargo.lock

@@ -34,6 +34,7 @@ url.workspace = true
 
 [dev-dependencies]
 blockifier = { workspace = true, features = ["testing"] }
+blockifier_test_utils.workspace = true
 rstest.workspace = true
 
 [lints]

crates/starknet_os_runner/Cargo.toml

@@ -2,7 +2,11 @@ use std::collections::{BTreeMap, HashMap, HashSet};
 use std::sync::Arc;
 
 use async_trait::async_trait;
-use blockifier::execution::contract_class::{CompiledClassV1, RunnableCompiledClass};
+use blockifier::execution::contract_class::{
+    program_hints_to_casm_hints,
+    CompiledClassV1,
+    RunnableCompiledClass,
+};
 use blockifier::state::state_api::StateReader;
 use blockifier::state::state_reader_and_contract_manager::{
     FetchCompiledClasses,
@@ -20,9 +24,10 @@ use crate::errors::ClassesProviderError;
 /// Converts a `CompiledClassV1` to a `CasmContractClass` for OS execution.
 /// Note: Some fields are not preserved in `CompiledClassV1` and are set to default values:
 /// - `compiler_version`: Set to empty string
-/// - `hints`: Set to empty (OS doesn't use them from this struct for Cairo 1 contracts)
 /// - `pythonic_hints`: Set to None
-fn compiled_class_v1_to_casm(class: &CompiledClassV1) -> CasmContractClass {
+pub(crate) fn compiled_class_v1_to_casm(
+    class: &CompiledClassV1,
+) -> Result<CasmContractClass, ClassesProviderError> {
     // TODO(Aviv): Consider using dummy prime since it is not used in the OS.
     let prime = Felt::prime();
 
@@ -35,15 +40,15 @@ fn compiled_class_v1_to_casm(class: &CompiledClassV1) -> CasmContractClass {
         })
         .collect();
 
-    CasmContractClass {
+    Ok(CasmContractClass {
         prime,
         compiler_version: String::new(),
         bytecode,
         bytecode_segment_lengths: Some(class.bytecode_segment_felt_sizes().into()),
-        hints: Vec::new(),
+        hints: program_hints_to_casm_hints(&class.program.shared_program_data.hints_collection)?,
         pythonic_hints: None,
         entry_points_by_type: (&class.entry_points_by_type).into(),
-    }
+    })
 }
 
 /// Fetch class from the state reader and contract manager.
@@ -65,13 +70,13 @@ where
             Err(ClassesProviderError::DeprecatedContractError(class_hash))
         }
         RunnableCompiledClass::V1(compiled_class_v1) => {
-            let casm = compiled_class_v1_to_casm(&compiled_class_v1);
+            let casm = compiled_class_v1_to_casm(&compiled_class_v1)?;
             Ok((compiled_class_hash, casm))
         }
         #[cfg(feature = "cairo_native")]
         RunnableCompiledClass::V1Native(compiled_class_v1_native) => {
             let compiled_class_v1 = compiled_class_v1_native.casm();
-            let casm = compiled_class_v1_to_casm(&compiled_class_v1);
+            let casm = compiled_class_v1_to_casm(&compiled_class_v1)?;
             Ok((compiled_class_hash, casm))
         }
     }

crates/starknet_os_runner/src/classes_provider.rs

@@ -0,0 +1,36 @@
+use blockifier::execution::contract_class::CompiledClassV1;
+use blockifier::test_utils::contracts::FeatureContractTrait;
+use blockifier_test_utils::cairo_versions::{CairoVersion, RunnableCairo1};
+use blockifier_test_utils::contracts::FeatureContract;
+use starknet_api::contract_class::ContractClass;
+
+use crate::classes_provider::compiled_class_v1_to_casm;
+
+/// Tests the round-trip conversion: CasmContractClass -> CompiledClassV1 -> CasmContractClass
+/// Verifies that all relevant fields are preserved (except compiler_version and pythonic_hints
+/// which are not loaded to the OS).
+#[test]
+fn test_compiled_class_v1_to_casm_round_trip() {
+    // Get a test contract that has hints and entry points.
+    let feature_contract =
+        FeatureContract::TestContract(CairoVersion::Cairo1(RunnableCairo1::Casm));
+    let (mut original_casm, sierra_version) = match feature_contract.get_class() {
+        ContractClass::V1(versioned_casm) => versioned_casm,
+        _ => panic!("Expected ContractClass::V1"),
+    };
+
+    // Ignore fields that are not loaded to the OS.
+    original_casm.compiler_version = String::new();
+    original_casm.pythonic_hints = None;
+
+    // Convert CasmContractClass to CompiledClassV1.
+    let compiled_class_v1 = CompiledClassV1::try_from((original_casm.clone(), sierra_version))
+        .expect("Failed to convert CasmContractClass to CompiledClassV1");
+
+    // Convert back to CasmContractClass using compiled_class_v1_to_casm.
+    let round_tripped_casm = compiled_class_v1_to_casm(&compiled_class_v1)
+        .expect("Failed to convert CompiledClassV1 back to CasmContractClass");
+
+    // Verify that the round-tripped CasmContractClass is equal to the original.
+    assert_eq!(round_tripped_casm, original_casm);
+}

crates/starknet_os_runner/src/classes_provider_test.rs

@@ -1,5 +1,6 @@
 use blockifier::state::errors::StateError;
 use blockifier_reexecution::errors::ReexecutionError;
+use cairo_vm::types::errors::program_errors::ProgramError;
 use starknet_api::core::ClassHash;
 use starknet_os::errors::StarknetOsError;
 use starknet_rust::providers::ProviderError;
@@ -49,4 +50,6 @@ pub enum ClassesProviderError {
     DeprecatedContractError(ClassHash),
     #[error(transparent)]
     StateError(#[from] StateError),
+    #[error(transparent)]
+    HintsConversionError(#[from] ProgramError),
 }

crates/starknet_os_runner/src/errors.rs

@@ -5,6 +5,8 @@ pub mod storage_proofs;
 pub mod tools;
 pub mod virtual_block_executor;
 
+#[cfg(test)]
+mod classes_provider_test;
 #[cfg(test)]
 mod storage_proofs_test;
 #[cfg(test)]