Remove cairo-lang-runner from runtime crate

commit-id:95f3fb16

Author: cptartur

Cargo.lock

@@ -71,7 +71,6 @@ pub(crate) fn execute_entry_point_call_cairo1(
         extension: CheatableStarknetRuntimeExtension { cheatnet_state },
         extended_runtime: StarknetRuntime {
             hint_handler: syscall_handler,
-            user_args: vec![],
             panic_traceback: None,
         },
     };

crates/cheatnet/src/runtime_extensions/call_to_blockifier_runtime_extension/execution/cairo1_execution.rs

@@ -106,7 +106,6 @@ pub fn run_config_pass(
         },
         extended_runtime: StarknetRuntime {
             hint_handler: syscall_handler,
-            user_args: vec![],
             panic_traceback: None,
         },
     };

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

@@ -10,7 +10,6 @@ testing = []
 indoc.workspace = true
 anyhow.workspace = true
 conversions.workspace = true
-cairo-lang-runner.workspace = true
 cairo-lang-casm.workspace = true
 cairo-lang-utils.workspace = true
 starknet-types-core.workspace = true

crates/runtime/Cargo.toml

@@ -1,11 +1,10 @@
+use crate::vm::{cell_ref_to_relocatable, extract_relocatable, get_val, vm_get_range};
 use anyhow::Result;
 use blockifier::execution::deprecated_syscalls::DeprecatedSyscallSelector;
 use blockifier::execution::syscalls::hint_processor::SyscallHintProcessor;
 use blockifier::state::errors::StateError;
 use cairo_lang_casm::hints::{ExternalHint, Hint, StarknetHint};
 use cairo_lang_casm::operand::{CellRef, ResOperand};
-use cairo_lang_runner::casm_run::{MemBuffer, extract_relocatable, get_val, vm_get_range};
-use cairo_lang_runner::{Arg, casm_run::cell_ref_to_relocatable, insert_value_to_cellref};
 use cairo_lang_utils::bigint::BigIntAsHex;
 use cairo_vm::hint_processor::hint_processor_definition::{
     HintProcessor, HintProcessorLogic, HintReference,
@@ -24,7 +23,6 @@ use conversions::serde::deserialize::BufferReader;
 use conversions::serde::serialize::raw::RawFeltVec;
 use conversions::serde::serialize::{CairoSerialize, SerializeToFeltVec};
 use indoc::indoc;
-use num_traits::cast::ToPrimitive;
 use shared::vm::VirtualMachineExt;
 use starknet_api::StarknetApiError;
 use starknet_types_core::felt::Felt;
@@ -34,6 +32,7 @@ use std::io;
 use thiserror::Error;
 
 pub mod starknet;
+mod vm;
 
 // from core/src/starknet/testing.cairo
 const CAIRO_TEST_CHEATCODES: [&str; 14] = [
@@ -58,10 +57,6 @@ pub trait SyscallPtrAccess {
 
 pub struct StarknetRuntime<'a> {
     pub hint_handler: SyscallHintProcessor<'a>,
-    // Required for handling `External` hints
-    //
-    // See https://github.com/starkware-libs/cairo/blob/dfb5d3fdcf80bff30c205c14163f99c890dbdc10/crates/cairo-lang-runner/src/casm_run/mod.rs#L94
-    pub user_args: Vec<Vec<Arg>>,
     pub panic_traceback: Option<Vec<usize>>,
 }
 
@@ -131,10 +126,6 @@ fn fetch_cheatcode_input(
     Ok(inputs)
 }
 
-fn args_size(args: &[Arg]) -> usize {
-    args.iter().map(Arg::size).sum()
-}
-
 impl HintProcessorLogic for StarknetRuntime<'_> {
     fn execute_hint(
         &mut self,
@@ -169,38 +160,6 @@ impl HintProcessorLogic for StarknetRuntime<'_> {
 
                     return Err(CustomHint(error.into()));
                 }
-                // Copied from https://github.com/starkware-libs/cairo/blob/3d5631d3f6563b5f97c11c816f530be99095a843/crates/cairo-lang-runner/src/casm_run/mod.rs#L1316
-                Hint::External(ExternalHint::AddRelocationRule { src, dst }) => {
-                    return Ok(vm.add_relocation_rule(
-                        extract_relocatable(vm, src)?,
-                        extract_relocatable(vm, dst)?,
-                    )?);
-                }
-                // Copied from https://github.com/starkware-libs/cairo/blob/3d5631d3f6563b5f97c11c816f530be99095a843/crates/cairo-lang-runner/src/casm_run/mod.rs#L1320
-                Hint::External(ExternalHint::WriteRunParam { index, dst }) => {
-                    let index = get_val(vm, index)?.to_usize().expect("Got a bad index.");
-                    let mut stack =
-                        vec![(cell_ref_to_relocatable(dst, vm), &self.user_args[index])];
-                    while let Some((mut buffer, values)) = stack.pop() {
-                        for value in values {
-                            match value {
-                                Arg::Value(v) => {
-                                    vm.insert_value(buffer, v)?;
-                                    buffer += 1;
-                                }
-                                Arg::Array(arr) => {
-                                    let arr_buffer = vm.add_memory_segment();
-                                    stack.push((arr_buffer, arr));
-                                    vm.insert_value(buffer, arr_buffer)?;
-                                    buffer += 1;
-                                    vm.insert_value(buffer, (arr_buffer + args_size(arr))?)?;
-                                    buffer += 1;
-                                }
-                            }
-                        }
-                    }
-                    return Ok(());
-                }
                 Hint::External(ExternalHint::AddTrace { flag }) => {
                     const PANIC_IN_BYTES: Felt = Felt::from_hex_unchecked("0x70616e6963");
                     let flag = get_val(vm, flag)?;
@@ -332,17 +291,15 @@ impl<Extension: ExtensionLogic> ExtendedRuntime<Extension> {
         }
         .serialize_to_vec();
 
-        let mut buffer = MemBuffer::new_segment(vm);
-        let result_start = buffer.ptr;
-        buffer
-            .write_data(res.iter())
-            .expect("Failed to insert cheatcode result to memory");
-        let result_end = buffer.ptr;
+        let WrittenData {
+            start: result_start,
+            end: result_end,
+        } = write_data(res, vm)?;
         let output_start = vm_io_ptrs.output_start;
         let output_end = vm_io_ptrs.output_end;
 
-        insert_value_to_cellref!(vm, output_start, result_start)?;
-        insert_value_to_cellref!(vm, output_end, result_end)?;
+        vm.insert_value(cell_ref_to_relocatable(*output_start, vm), result_start)?;
+        vm.insert_value(cell_ref_to_relocatable(*output_end, vm), result_end)?;
 
         self.propagate_cheatcode_signal(&selector, &inputs);
 
@@ -529,3 +486,18 @@ impl From<BufferReadError> for EnhancedHintError {
             )
     }
 }
+
+struct WrittenData {
+    start: Relocatable,
+    end: Relocatable,
+}
+
+fn write_data(data: Vec<Felt>, vm: &mut VirtualMachine) -> Result<WrittenData, HintError> {
+    let mut ptr = vm.add_memory_segment();
+    let start = ptr;
+    for data in data {
+        vm.insert_value(ptr, data)?;
+        ptr += 1;
+    }
+    Ok(WrittenData { start, end: ptr })
+}

crates/runtime/src/lib.rs

@@ -0,0 +1,108 @@
+//! Contains code copied from `cairo-lang-runner`
+use cairo_lang_casm::operand::{
+    BinOpOperand, CellRef, DerefOrImmediate, Operation, Register, ResOperand,
+};
+use cairo_lang_utils::extract_matches;
+use cairo_vm::Felt252;
+use cairo_vm::types::relocatable::Relocatable;
+use cairo_vm::vm::errors::hint_errors::HintError;
+use cairo_vm::vm::errors::vm_errors::VirtualMachineError;
+use cairo_vm::vm::vm_core::VirtualMachine;
+
+pub fn cell_ref_to_relocatable(cell_ref: CellRef, vm: &VirtualMachine) -> Relocatable {
+    let base = match cell_ref.register {
+        Register::AP => vm.get_ap(),
+        Register::FP => vm.get_fp(),
+    };
+    (base + i32::from(cell_ref.offset)).unwrap()
+}
+
+/// Extracts a parameter assumed to be a buffer.
+fn extract_buffer(buffer: &ResOperand) -> (CellRef, Felt252) {
+    let (cell, base_offset) = match buffer {
+        ResOperand::Deref(cell) => (cell, 0.into()),
+        ResOperand::BinOp(BinOpOperand {
+            op: Operation::Add,
+            a,
+            b,
+        }) => (
+            a,
+            extract_matches!(b, DerefOrImmediate::Immediate)
+                .clone()
+                .value
+                .into(),
+        ),
+        _ => panic!("Illegal argument for a buffer."),
+    };
+    (*cell, base_offset)
+}
+
+/// Fetches the value of a cell plus an offset from the vm, useful for pointers.
+fn get_ptr(
+    vm: &VirtualMachine,
+    cell: CellRef,
+    offset: &Felt252,
+) -> Result<Relocatable, VirtualMachineError> {
+    Ok((vm.get_relocatable(cell_ref_to_relocatable(cell, vm))? + offset)?)
+}
+
+/// Extracts a parameter assumed to be a buffer, and converts it into a relocatable.
+pub fn extract_relocatable(
+    vm: &VirtualMachine,
+    buffer: &ResOperand,
+) -> Result<Relocatable, VirtualMachineError> {
+    let (base, offset) = extract_buffer(buffer);
+    get_ptr(vm, base, &offset)
+}
+
+pub fn vm_get_range(
+    vm: &mut VirtualMachine,
+    mut calldata_start_ptr: Relocatable,
+    calldata_end_ptr: Relocatable,
+) -> Result<Vec<Felt252>, HintError> {
+    let mut values = vec![];
+    while calldata_start_ptr != calldata_end_ptr {
+        let val = *vm.get_integer(calldata_start_ptr)?;
+        values.push(val);
+        calldata_start_ptr.offset += 1;
+    }
+    Ok(values)
+}
+
+pub(crate) fn get_cell_val(
+    vm: &VirtualMachine,
+    cell: CellRef,
+) -> Result<Felt252, VirtualMachineError> {
+    Ok(*vm.get_integer(cell_ref_to_relocatable(cell, vm))?.as_ref())
+}
+
+fn get_double_deref_val(
+    vm: &VirtualMachine,
+    cell: CellRef,
+    offset: &Felt252,
+) -> Result<Felt252, VirtualMachineError> {
+    Ok(*vm.get_integer(get_ptr(vm, cell, offset)?)?)
+}
+
+/// Fetches the value of `res_operand` from the vm.
+pub fn get_val(
+    vm: &VirtualMachine,
+    res_operand: &ResOperand,
+) -> Result<Felt252, VirtualMachineError> {
+    match res_operand {
+        ResOperand::Deref(cell) => get_cell_val(vm, *cell),
+        ResOperand::DoubleDeref(cell, offset) => get_double_deref_val(vm, *cell, &(*offset).into()),
+        ResOperand::Immediate(x) => Ok(Felt252::from(x.value.clone())),
+        ResOperand::BinOp(op) => {
+            let a = get_cell_val(vm, op.a)?;
+            let b = match &op.b {
+                DerefOrImmediate::Deref(cell) => get_cell_val(vm, *cell)?,
+                DerefOrImmediate::Immediate(x) => Felt252::from(x.value.clone()),
+            };
+            match op.op {
+                Operation::Add => Ok(a + b),
+                Operation::Mul => Ok(a * b),
+            }
+        }
+    }
+}