Remove cairo-lang-runner dependency from forge runner

commit-id:a1c233ca

Author: cptartur

Cargo.lock

@@ -79,6 +79,32 @@ impl FromShortString<Felt> for Felt {
     }
 }
 
+#[derive(Debug)]
+pub struct ToStrErr;
+
+pub trait ToShortString<T>: Sized {
+    fn to_short_string(&self) -> Result<String, ToStrErr>;
+}
+
+impl ToShortString<Felt> for Felt {
+    fn to_short_string(&self) -> Result<String, ToStrErr> {
+        let mut as_string = String::default();
+        let mut is_end = false;
+        for byte in self.to_biguint().to_bytes_be() {
+            if byte == 0 {
+                is_end = true;
+            } else if is_end {
+                return Err(ToStrErr);
+            } else if byte.is_ascii_graphic() || byte.is_ascii_whitespace() {
+                as_string.push(byte as char);
+            } else {
+                return Err(ToStrErr);
+            }
+        }
+        Ok(as_string)
+    }
+}
+
 pub trait TryInferFormat: Sized {
     /// Parses value from `hex string`, `dec string`, `quotted cairo shortstring `and `quotted cairo string`
     fn infer_format_and_parse(value: &str) -> Result<Vec<Self>, FromStrError>;
@@ -105,3 +131,80 @@ impl TryInferFormat for Felt {
         }
     }
 }
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn short_string_happy_case() {
+        let felt = Felt::from_hex("0x616263646566").unwrap();
+        assert_eq!(felt.to_short_string().unwrap(), "abcdef");
+    }
+
+    #[test]
+    fn short_string_31_characters() {
+        let felt =
+            Felt::from_hex("0x4142434445464748494a4b4c4d4e4f505152535455565758595a3132333435")
+                .unwrap();
+        assert_eq!(
+            felt.to_short_string().unwrap(),
+            "ABCDEFGHIJKLMNOPQRSTUVWXYZ12345"
+        );
+    }
+
+    #[test]
+    fn short_string_too_long() {
+        let felt =
+            Felt::from_hex("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")
+                .unwrap();
+        assert!(felt.to_short_string().is_err());
+    }
+
+    #[test]
+    fn short_string_empty() {
+        let felt = Felt::from_hex("0x0").unwrap();
+        assert_eq!(felt.to_short_string().unwrap(), "");
+    }
+
+    #[test]
+    fn short_string_with_whitespace() {
+        let felt = Felt::from_hex("0x48656C6C6F20576F726C64").unwrap();
+        assert_eq!(felt.to_short_string().unwrap(), "Hello World");
+    }
+
+    #[test]
+    fn short_string_special_chars() {
+        let felt = Felt::from_hex("0x4021233F2A2B5B5D").unwrap();
+        assert_eq!(felt.to_short_string().unwrap(), "@!#?*+[]");
+    }
+
+    #[test]
+    fn short_string_with_numbers() {
+        let felt = Felt::from_hex("0x313233343536373839").unwrap();
+        assert_eq!(felt.to_short_string().unwrap(), "123456789");
+    }
+
+    #[test]
+    fn short_string_non_ascii() {
+        let felt = Felt::from_hex("0x80").unwrap();
+        assert!(felt.to_short_string().is_err());
+    }
+
+    #[test]
+    fn short_string_null_byte() {
+        let felt = Felt::from_hex("0x00616263").unwrap();
+        assert_eq!(felt.to_short_string().unwrap(), "abc");
+    }
+
+    #[test]
+    fn short_string_null_byte_middle() {
+        let felt = Felt::from_hex("0x61006263").unwrap();
+        assert!(felt.to_short_string().is_err());
+    }
+
+    #[test]
+    fn short_string_null_byte_end() {
+        let felt = Felt::from_hex("0x61626300").unwrap();
+        assert_eq!(felt.to_short_string().unwrap(), "abc");
+    }
+}

crates/conversions/src/felt.rs

@@ -7,8 +7,6 @@ edition.workspace = true
 
 [dependencies]
 anyhow.workspace = true
-cairo-lang-runner.workspace = true
-cairo-lang-runnable-utils.workspace = true
 cairo-lang-casm.workspace = true
 cairo-lang-sierra.workspace = true
 cairo-lang-utils.workspace = true

crates/forge-runner/Cargo.toml

@@ -8,7 +8,6 @@ use crate::{forge_config::ForgeTrackedResource, package_tests::TestDetails};
 use anyhow::Result;
 use blockifier::execution::contract_class::TrackedResource;
 use blockifier::state::{cached_state::CachedState, state_api::StateReader};
-use cairo_lang_runner::Arg;
 use cheatnet::runtime_extensions::forge_config_extension::{
     ForgeConfigExtension, config::RawForgeConfig,
 };
@@ -107,12 +106,7 @@ pub fn run_config_pass(
         },
         extended_runtime: StarknetRuntime {
             hint_handler: syscall_handler,
-            // Max gas is no longer set by `create_entry_code_from_params`
-            // Instead, call to `ExternalHint::WriteRunParam` is added by it, and we need to
-            // store the gas value to be read by logic handling the hint
-            // TODO(#2966) we should subtract initial cost of the function from this value to be more exact.
-            //  But as a workaround it should be good enough.
-            user_args: vec![vec![Arg::Value(Felt::from(i64::MAX))]],
+            user_args: vec![],
             panic_traceback: None,
         },
     };

crates/forge-runner/src/running/config_run.rs

@@ -1,6 +1,5 @@
 use cairo_lang_casm::hints::Hint;
-use cairo_lang_runner::casm_run::hint_to_hint_params;
-use cairo_vm::serde::deserialize_program::HintParams;
+use cairo_vm::serde::deserialize_program::{ApTracking, FlowTrackingData, HintParams};
 use std::collections::HashMap;
 use universal_sierra_compiler_api::AssembledCairoProgramWithSerde;
 
@@ -27,7 +26,14 @@ pub fn hints_to_params(
                 *offset,
                 hints
                     .iter()
-                    .map(hint_to_hint_params)
+                    .map(|hint| HintParams {
+                        code: hint.representing_string(),
+                        accessible_scopes: vec![],
+                        flow_tracking_data: FlowTrackingData {
+                            ap_tracking: ApTracking::new(),
+                            reference_ids: HashMap::new(),
+                        },
+                    })
                     .collect::<Vec<HintParams>>(),
             )
         })

crates/forge-runner/src/running/hints.rs

@@ -6,11 +6,11 @@ use crate::gas::check_available_gas;
 use crate::package_tests::with_config_resolved::TestCaseWithResolvedConfig;
 use crate::running::{RunCompleted, RunStatus};
 use cairo_annotations::trace_data::VersionedCallTrace as VersionedProfilerCallTrace;
-use cairo_lang_runner::short_string::as_cairo_short_string;
 use camino::Utf8Path;
 use cheatnet::runtime_extensions::call_to_blockifier_runtime_extension::rpc::UsedResources;
 use cheatnet::runtime_extensions::forge_runtime_extension::contracts_data::ContractsData;
 use conversions::byte_array::ByteArray;
+use conversions::felt::ToShortString;
 use num_traits::Pow;
 use shared::utils::build_readable_text;
 use starknet_api::execution_resources::GasVector;
@@ -404,7 +404,7 @@ impl TestCaseSummary<Single> {
 
 fn join_short_strings(data: &[Felt]) -> String {
     data.iter()
-        .map(|felt| as_cairo_short_string(felt).unwrap_or_default())
+        .map(|felt| felt.to_short_string().unwrap_or_default())
         .collect::<Vec<String>>()
         .join(", ")
 }