Revert "feat: implement Cairo Function Runner and related updates (#2352)" (#2357)

This reverts commit 4fda146.

Author: YairVaknin-starkware

CHANGELOG.md

@@ -18,10 +18,6 @@ Both branches support Stwo prover opcodes (Blake2s, QM31) since v2.0.0.
 
 * fix: Fix off-by-one comparisons in `split_int`, `assert_250_bit`, and `sqrt` hints [#2348](https://github.com/lambdaclass/cairo-vm/pull/2348)
 
-* chore: Add `CairoFunctionRunner` for running Cairo entrypoints by name or PC, and broaden `CairoArg`/`MaybeRelocatable` conversions to support primitive signed/unsigned integers and big integers [#2352](https://github.com/lambdaclass/cairo-vm/pull/2352)
-
-* chore: Add unit tests for `CairoFunctionRunner`, `CairoArg` conversions/macros, and `MaybeRelocatable` conversion macro coverage [#2354](https://github.com/lambdaclass/cairo-vm/pull/2354)
-
 #### [3.2.0] - 2026-3-3
 
 * fix: Change extended_resource_counter entry from u32 to usize [#2349](https://github.com/lambdaclass/cairo-vm/pull/2349)

README.md

@@ -246,6 +246,19 @@ When running a Cairo program directly using the Cairo-vm repository you would fi
   cairo_runner.initialize_segments(None);
   ```
 
+When using cairo-vm with the Starknet devnet there are additional parameters that are part of the OS context passed on to the `run_from_entrypoint` method that we do not have here when using it directly. These parameters are, for example, initial stacks of the builtins, which are the base of each of them and are needed as they are the implicit arguments of the function.
+
+```rust
+ let _var = cairo_runner.run_from_entrypoint(
+            entrypoint,
+            vec![
+                &MaybeRelocatable::from(2).into(),  //this is the entry point selector
+                &MaybeRelocatable::from((2,0)).into() //this would be the output_ptr for example if our cairo function uses it
+                ],
+            false,
+            &mut hint_processor,
+        );
+```
 ### Running cairo 1 programs
 
 To run a cairo 1 program enter in the folder `cd cairo1-run` and follow the [`cairo1-run documentation`](cairo1-run/README.md)

vm/src/math_utils/mod.rs

@@ -397,7 +397,7 @@ fn legendre_symbol(a: &BigUint, p: &BigUint) -> i8 {
 // Ported from sympy implementation
 // Simplified as a & p are nonnegative
 // Asumes p is a prime number
-pub fn is_quad_residue(a: &BigUint, p: &BigUint) -> Result<bool, MathError> {
+pub(crate) fn is_quad_residue(a: &BigUint, p: &BigUint) -> Result<bool, MathError> {
     if p.is_zero() {
         return Err(MathError::IsQuadResidueZeroPrime);
     }

vm/src/tests/mod.rs

@@ -10,10 +10,7 @@ use crate::Felt252;
 use crate::{
     hint_processor::cairo_1_hint_processor::hint_processor::Cairo1HintProcessor,
     types::{builtin_name::BuiltinName, relocatable::MaybeRelocatable},
-    vm::runners::{
-        cairo_function_runner::{CairoFunctionRunner, EntryPoint},
-        cairo_runner::CairoArg,
-    },
+    vm::runners::cairo_runner::{CairoArg, CairoRunner},
 };
 #[cfg(feature = "cairo-1-hints")]
 use cairo_lang_starknet_classes::casm_contract_class::CasmContractClass;
@@ -107,7 +104,7 @@ fn run_cairo_1_entrypoint(
     let mut hint_processor =
         Cairo1HintProcessor::new(&contract_class.hints, RunResources::default(), false);
 
-    let mut function_runner = CairoFunctionRunner::new_custom(
+    let mut runner = CairoRunner::new(
         &(contract_class.clone().try_into().unwrap()),
         LayoutName::all_cairo,
         None,
@@ -118,16 +115,16 @@ fn run_cairo_1_entrypoint(
     .unwrap();
 
     let program_builtins = get_casm_contract_builtins(&contract_class, entrypoint_offset);
-    function_runner
+    runner
         .initialize_function_runner_cairo_1(&program_builtins)
         .unwrap();
 
     // Implicit Args
-    let syscall_segment = MaybeRelocatable::from(function_runner.vm.add_memory_segment());
+    let syscall_segment = MaybeRelocatable::from(runner.vm.add_memory_segment());
 
-    let builtins = function_runner.get_program_builtins();
+    let builtins = runner.get_program_builtins();
 
-    let builtin_segment: Vec<MaybeRelocatable> = function_runner
+    let builtin_segment: Vec<MaybeRelocatable> = runner
         .vm
         .get_builtin_runners()
         .iter()
@@ -144,33 +141,27 @@ fn run_cairo_1_entrypoint(
     // Other args
 
     // Load builtin costs
-    let builtin_costs: Vec<MaybeRelocatable> = vec![
-        0_i64.into(),
-        0_i64.into(),
-        0_i64.into(),
-        0_i64.into(),
-        0_i64.into(),
-    ];
-    let builtin_costs_ptr = function_runner.vm.add_memory_segment();
-    function_runner
+    let builtin_costs: Vec<MaybeRelocatable> =
+        vec![0.into(), 0.into(), 0.into(), 0.into(), 0.into()];
+    let builtin_costs_ptr = runner.vm.add_memory_segment();
+    runner
         .vm
         .load_data(builtin_costs_ptr, &builtin_costs)
         .unwrap();
 
     // Load extra data
-    let core_program_end_ptr = (function_runner.program_base.unwrap()
-        + function_runner.program.shared_program_data.data.len())
-    .unwrap();
+    let core_program_end_ptr =
+        (runner.program_base.unwrap() + runner.program.shared_program_data.data.len()).unwrap();
     let program_extra_data: Vec<MaybeRelocatable> =
-        vec![0x208B7FFF7FFF7FFE_u64.into(), builtin_costs_ptr.into()];
-    function_runner
+        vec![0x208B7FFF7FFF7FFE.into(), builtin_costs_ptr.into()];
+    runner
         .vm
         .load_data(core_program_end_ptr, &program_extra_data)
         .unwrap();
 
     // Load calldata
-    let calldata_start = function_runner.vm.add_memory_segment();
-    let calldata_end = function_runner.vm.load_data(calldata_start, args).unwrap();
+    let calldata_start = runner.vm.add_memory_segment();
+    let calldata_end = runner.vm.load_data(calldata_start, args).unwrap();
 
     // Create entrypoint_args
 
@@ -182,26 +173,25 @@ fn run_cairo_1_entrypoint(
         MaybeRelocatable::from(calldata_start).into(),
         MaybeRelocatable::from(calldata_end).into(),
     ]);
+    let entrypoint_args: Vec<&CairoArg> = entrypoint_args.iter().collect();
 
     // Run contract entrypoint
 
-    let program_segment_size =
-        function_runner.program.shared_program_data.data.len() + program_extra_data.len();
-    function_runner
-        .run(
-            EntryPoint::Pc(entrypoint_offset),
+    runner
+        .run_from_entrypoint(
+            entrypoint_offset,
+            &entrypoint_args,
             true,
-            Some(program_segment_size),
+            Some(runner.program.shared_program_data.data.len() + program_extra_data.len()),
             &mut hint_processor,
-            &entrypoint_args,
         )
         .unwrap();
 
     // Check return values
-    let return_values = function_runner.vm.get_return_values(5).unwrap();
+    let return_values = runner.vm.get_return_values(5).unwrap();
     let retdata_start = return_values[3].get_relocatable().unwrap();
     let retdata_end = return_values[4].get_relocatable().unwrap();
-    let retdata: Vec<Felt252> = function_runner
+    let retdata: Vec<Felt252> = runner
         .vm
         .get_integer_range(retdata_start, (retdata_end - retdata_start).unwrap())
         .unwrap()
@@ -221,7 +211,7 @@ fn run_cairo_1_entrypoint_with_run_resources(
     hint_processor: &mut Cairo1HintProcessor,
     args: &[MaybeRelocatable],
 ) -> Result<Vec<Felt252>, CairoRunError> {
-    let mut function_runner = CairoFunctionRunner::new_custom(
+    let mut runner = CairoRunner::new(
         &(contract_class.clone().try_into().unwrap()),
         LayoutName::all_cairo,
         None,
@@ -232,16 +222,16 @@ fn run_cairo_1_entrypoint_with_run_resources(
     .unwrap();
 
     let program_builtins = get_casm_contract_builtins(&contract_class, entrypoint_offset);
-    function_runner
+    runner
         .initialize_function_runner_cairo_1(&program_builtins)
         .unwrap();
 
     // Implicit Args
-    let syscall_segment = MaybeRelocatable::from(function_runner.vm.add_memory_segment());
+    let syscall_segment = MaybeRelocatable::from(runner.vm.add_memory_segment());
 
-    let builtins = function_runner.get_program_builtins();
+    let builtins = runner.get_program_builtins();
 
-    let builtin_segment: Vec<MaybeRelocatable> = function_runner
+    let builtin_segment: Vec<MaybeRelocatable> = runner
         .vm
         .get_builtin_runners()
         .iter()
@@ -258,33 +248,27 @@ fn run_cairo_1_entrypoint_with_run_resources(
     // Other args
 
     // Load builtin costs
-    let builtin_costs: Vec<MaybeRelocatable> = vec![
-        0_i64.into(),
-        0_i64.into(),
-        0_i64.into(),
-        0_i64.into(),
-        0_i64.into(),
-    ];
-    let builtin_costs_ptr = function_runner.vm.add_memory_segment();
-    function_runner
+    let builtin_costs: Vec<MaybeRelocatable> =
+        vec![0.into(), 0.into(), 0.into(), 0.into(), 0.into()];
+    let builtin_costs_ptr = runner.vm.add_memory_segment();
+    runner
         .vm
         .load_data(builtin_costs_ptr, &builtin_costs)
         .unwrap();
 
     // Load extra data
-    let core_program_end_ptr = (function_runner.program_base.unwrap()
-        + function_runner.program.shared_program_data.data.len())
-    .unwrap();
+    let core_program_end_ptr =
+        (runner.program_base.unwrap() + runner.program.shared_program_data.data.len()).unwrap();
     let program_extra_data: Vec<MaybeRelocatable> =
-        vec![0x208B7FFF7FFF7FFE_u64.into(), builtin_costs_ptr.into()];
-    function_runner
+        vec![0x208B7FFF7FFF7FFE.into(), builtin_costs_ptr.into()];
+    runner
         .vm
         .load_data(core_program_end_ptr, &program_extra_data)
         .unwrap();
 
     // Load calldata
-    let calldata_start = function_runner.vm.add_memory_segment();
-    let calldata_end = function_runner.vm.load_data(calldata_start, args).unwrap();
+    let calldata_start = runner.vm.add_memory_segment();
+    let calldata_end = runner.vm.load_data(calldata_start, args).unwrap();
 
     // Create entrypoint_args
 
@@ -296,24 +280,23 @@ fn run_cairo_1_entrypoint_with_run_resources(
         MaybeRelocatable::from(calldata_start).into(),
         MaybeRelocatable::from(calldata_end).into(),
     ]);
+    let entrypoint_args: Vec<&CairoArg> = entrypoint_args.iter().collect();
 
     // Run contract entrypoint
 
-    let program_segment_size =
-        function_runner.program.shared_program_data.data.len() + program_extra_data.len();
-    function_runner.run(
-        EntryPoint::Pc(entrypoint_offset),
+    runner.run_from_entrypoint(
+        entrypoint_offset,
+        &entrypoint_args,
         true,
-        Some(program_segment_size),
+        Some(runner.program.shared_program_data.data.len() + program_extra_data.len()),
         hint_processor,
-        &entrypoint_args,
     )?;
 
     // Check return values
-    let return_values = function_runner.vm.get_return_values(5).unwrap();
+    let return_values = runner.vm.get_return_values(5).unwrap();
     let retdata_start = return_values[3].get_relocatable().unwrap();
     let retdata_end = return_values[4].get_relocatable().unwrap();
-    let retdata: Vec<Felt252> = function_runner
+    let retdata: Vec<Felt252> = runner
         .vm
         .get_integer_range(retdata_start, (retdata_end - retdata_start).unwrap())
         .unwrap()

vm/src/types/relocatable.rs

@@ -7,7 +7,6 @@ use crate::Felt252;
 use crate::{
     relocatable, types::errors::math_errors::MathError, vm::errors::memory_errors::MemoryError,
 };
-use num_bigint::{BigInt, BigUint};
 use num_traits::ToPrimitive;
 use serde::{Deserialize, Serialize};
 
@@ -59,6 +58,12 @@ impl From<(isize, usize)> for MaybeRelocatable {
     }
 }
 
+impl From<usize> for MaybeRelocatable {
+    fn from(num: usize) -> Self {
+        MaybeRelocatable::Int(Felt252::from(num))
+    }
+}
+
 impl From<Felt252> for MaybeRelocatable {
     fn from(num: Felt252) -> Self {
         MaybeRelocatable::Int(num)
@@ -89,25 +94,6 @@ impl From<Relocatable> for MaybeRelocatable {
     }
 }
 
-// Implement primitive and big-int (owned + reference) conversions by first converting to Felt252,
-// then wrapping as MaybeRelocatable::Int.
-macro_rules! impl_from_for_maybe_relocatable {
-    ($($t:ty),* $(,)?) => {
-        $(
-            impl From<$t> for MaybeRelocatable {
-                fn from(num: $t) -> Self {
-                    MaybeRelocatable::Int(Felt252::from(num))
-                }
-            }
-        )*
-    };
-}
-
-impl_from_for_maybe_relocatable!(
-    u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, BigUint, BigInt, &BigUint,
-    &BigInt
-);
-
 impl Display for MaybeRelocatable {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
@@ -410,7 +396,6 @@ mod tests {
     use super::*;
     use crate::{felt_hex, felt_str};
     use crate::{relocatable, utils::test_utils::mayberelocatable};
-    use num_bigint::{BigInt, BigUint};
 
     use proptest::prelude::*;
 
@@ -444,45 +429,6 @@ mod tests {
         }
     }
 
-    #[test]
-    // Verifies primitive integers convert into `MaybeRelocatable::Int` via the macro-generated impls.
-    fn maybe_relocatable_from_primitive_via_macro() {
-        let value = MaybeRelocatable::from(42_u8);
-        assert_eq!(value, MaybeRelocatable::Int(Felt252::from(42_u8)));
-    }
-
-    #[test]
-    // Verifies owned `BigUint`/`BigInt` values convert into `MaybeRelocatable::Int`.
-    fn maybe_relocatable_from_owned_bigints_via_macro() {
-        let big_uint = BigUint::from(123_u32);
-        let big_int = BigInt::from(456_i32);
-
-        assert_eq!(
-            MaybeRelocatable::from(big_uint),
-            MaybeRelocatable::Int(Felt252::from(123_u32))
-        );
-        assert_eq!(
-            MaybeRelocatable::from(big_int),
-            MaybeRelocatable::Int(Felt252::from(456_i32))
-        );
-    }
-
-    #[test]
-    // Verifies referenced `&BigUint`/`&BigInt` values convert into `MaybeRelocatable::Int`.
-    fn maybe_relocatable_from_referenced_bigints_via_macro() {
-        let big_uint = BigUint::from(789_u32);
-        let big_int = BigInt::from(321_i32);
-
-        assert_eq!(
-            MaybeRelocatable::from(&big_uint),
-            MaybeRelocatable::Int(Felt252::from(789_u32))
-        );
-        assert_eq!(
-            MaybeRelocatable::from(&big_int),
-            MaybeRelocatable::Int(Felt252::from(321_i32))
-        );
-    }
-
     #[test]
     fn add_bigint_to_int() {
         let addr = MaybeRelocatable::from(Felt252::from(7i32));