Add_support_for_pies_with_simulated_builtins

Author: YairVaknin-starkware

vm/src/cairo_run.rs

@@ -177,6 +177,8 @@ pub fn cairo_run_pie(
 
     let end = cairo_runner.initialize(allow_missing_builtins)?;
     cairo_runner.vm.finalize_segments_by_cairo_pie(pie);
+    // Load simulated builtin runners according to the pie's metadata.
+    cairo_runner.load_simulated_builtin_runners(&pie.metadata.simulated_builtins)?;
     // Load builtin additional data
     for (name, data) in pie.additional_data.0.iter() {
         // Data is not trusted in secure_run, therefore we skip extending the hash builtin's data

vm/src/tests/cairo_pie_test.rs

@@ -3,6 +3,12 @@ use crate::{
     types::{builtin_name::BuiltinName, layout_name::LayoutName},
 };
 
+#[cfg(feature = "mod_builtin")]
+use crate::{
+    cairo_run,
+    vm::runners::{cairo_pie::CairoPie, cairo_runner::RunResources},
+};
+
 #[cfg(target_arch = "wasm32")]
 use wasm_bindgen_test::*;
 
@@ -282,3 +288,28 @@ fn run_pie_validity_checks_integration() {
     let cairo_pie = runner.get_cairo_pie().expect("Failed to get pie");
     assert!(cairo_pie.run_validity_checks().is_ok())
 }
+
+#[test]
+#[cfg(feature = "std")]
+#[cfg(feature = "mod_builtin")]
+fn get_cairo_pie_with_simulated_builtins() {
+    // Load a Cairo PIE with simulated builtins (this PIE is of a run of the simple_bootloader
+    // program, with a subtask that uses all available builtins, simulating the ones not present in
+    // the `all_cairo_stwo` layout).
+    let pie =
+        CairoPie::from_bytes(include_bytes!("cairo_pie_with_simulated_builtins.zip")).unwrap();
+    let mut hint_processor = BuiltinHintProcessor::new(
+        Default::default(),
+        RunResources::new(pie.execution_resources.n_steps),
+    );
+    let cairo_run_config = CairoRunConfig {
+        layout: LayoutName::all_cairo_stwo,
+        secure_run: Some(true),
+        allow_missing_builtins: Some(true),
+        ..Default::default()
+    };
+    let result = cairo_run::cairo_run_pie(&pie, &cairo_run_config, &mut hint_processor);
+    let runner = result.unwrap();
+    let result = runner.get_cairo_pie();
+    assert!(result.is_ok());
+}

vm/src/tests/cairo_pie_with_simulated_builtins.zip

@@ -3,6 +3,7 @@ use thiserror::Error;
 use super::cairo_pie_errors::CairoPieValidationError;
 use super::memory_errors::MemoryError;
 use super::vm_exception::VmException;
+use crate::types::builtin_name::BuiltinName;
 use crate::types::errors::program_errors::ProgramError;
 use crate::vm::errors::{
     runner_errors::RunnerError, trace_errors::TraceError, vm_errors::VirtualMachineError,
@@ -26,4 +27,6 @@ pub enum CairoRunError {
     VmException(#[from] VmException),
     #[error(transparent)]
     CairoPieValidation(#[from] CairoPieValidationError),
+    #[error("Unsupported simulated builtin in Cairo PIE: {0:?}")]
+    UnsupportedSimulatedBuiltin(BuiltinName),
 }

vm/src/vm/errors/cairo_run_errors.rs

@@ -147,6 +147,11 @@ pub struct CairoPieMetadata {
     #[serde(serialize_with = "serde_impl::serialize_builtin_segments")]
     pub builtin_segments: HashMap<BuiltinName, SegmentInfo>,
     pub extra_segments: Vec<SegmentInfo>,
+    // `simulated_builtins` are builtins that are being verified in the executed cairo code
+    // rather than being outputted as their own segment and proven later (see example implementation
+    // of this mechanism in `simple_bootloader.cairo`).
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub simulated_builtins: Vec<BuiltinName>,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
@@ -175,12 +180,11 @@ impl CairoPieMetadata {
         if self.program.data.len() != self.program_segment.size {
             return Err(CairoPieValidationError::ProgramLenVsSegmentSizeMismatch);
         }
-        if self.builtin_segments.len() != self.program.builtins.len()
-            || !self
-                .program
-                .builtins
-                .iter()
-                .all(|b| self.builtin_segments.contains_key(b))
+        if self.builtin_segments.len() + self.simulated_builtins.len()
+            != self.program.builtins.len()
+            || !self.program.builtins.iter().all(|b| {
+                self.builtin_segments.contains_key(b) || self.simulated_builtins.contains(b)
+            })
         {
             return Err(CairoPieValidationError::BuiltinListVsSegmentsMismatch);
         }
@@ -200,23 +204,32 @@ impl CairoPieMetadata {
         if !self.execution_segment.index.is_one() {
             return Err(CairoPieValidationError::InvalidExecutionSegmentIndex);
         }
-        for (i, builtin_name) in self.program.builtins.iter().enumerate() {
-            // We can safely index as run_validity_checks already ensures that the keys match
-            if self.builtin_segments[builtin_name].index != 2 + i as isize {
+        let mut non_simulated_index = 0;
+        for builtin_name in self.program.builtins.iter() {
+            // We can safely index as run_validity_checks already ensures that the keys match,
+            // to either a builtin_segments key or a simulated_builtins key.
+            // If the builtin is simulated, skip processing without incrementing non_simulated_index.
+            if self.simulated_builtins.contains(builtin_name) {
+                continue;
+            }
+
+            if self.builtin_segments[builtin_name].index != 2 + non_simulated_index as isize {
                 return Err(CairoPieValidationError::InvalidBuiltinSegmentIndex(
                     *builtin_name,
                 ));
             }
+            non_simulated_index += 1;
         }
-        let n_builtins = self.program.builtins.len() as isize;
-        if self.ret_fp_segment.index != n_builtins + 2 {
+        let n_builtin_segments =
+            (self.program.builtins.len() - self.simulated_builtins.len()) as isize;
+        if self.ret_fp_segment.index != n_builtin_segments + 2 {
             return Err(CairoPieValidationError::InvalidRetFpSegmentIndex);
         }
-        if self.ret_pc_segment.index != n_builtins + 3 {
+        if self.ret_pc_segment.index != n_builtin_segments + 3 {
             return Err(CairoPieValidationError::InvalidRetPcSegmentIndex);
         }
         for (i, segment) in self.extra_segments.iter().enumerate() {
-            if segment.index != 4 + n_builtins + i as isize {
+            if segment.index != 4 + n_builtin_segments + i as isize {
                 return Err(CairoPieValidationError::InvalidExtraSegmentIndex);
             }
         }
@@ -230,11 +243,13 @@ impl CairoPie {
         self.metadata.run_validity_checks()?;
         self.run_memory_validity_checks()?;
         if self.execution_resources.builtin_instance_counter.len()
+            + self.metadata.simulated_builtins.len()
             != self.metadata.program.builtins.len()
             || !self.metadata.program.builtins.iter().all(|b| {
                 self.execution_resources
                     .builtin_instance_counter
                     .contains_key(b)
+                    || self.metadata.simulated_builtins.contains(b)
             })
         {
             return Err(CairoPieValidationError::BuiltinListVsSegmentsMismatch);

vm/src/vm/runners/cairo_pie.rs

@@ -1405,18 +1405,36 @@ impl CairoRunner {
             }
         }
 
+        let stripped_program = self
+            .get_program()
+            .get_stripped_program()
+            .map_err(|_| RunnerError::StrippedProgramNoMain)?;
+        let mut simulated_builtins = self
+            .vm
+            .simulated_builtin_runners
+            .iter()
+            .map(|builtin| builtin.name())
+            .collect::<Vec<_>>();
+        // Sort the simulated builtins by their order in the program, so their order is aligned
+        // when used (for example, in the simple bootloader when setting up the pre execution
+        // builtin pointers of a CairoPIE subtask).
+        simulated_builtins.sort_by_key(|builtin| {
+            stripped_program
+                .builtins
+                .iter()
+                .position(|b| b == builtin)
+                .unwrap()
+        });
         let execution_size = (self.vm.get_ap() - execution_base)?;
         let metadata = CairoPieMetadata {
-            program: self
-                .get_program()
-                .get_stripped_program()
-                .map_err(|_| RunnerError::StrippedProgramNoMain)?,
+            program: stripped_program,
             program_segment: (program_base.segment_index, self.program.data_len()).into(),
             execution_segment: (execution_base.segment_index, execution_size).into(),
             ret_fp_segment: (return_fp.segment_index, 0).into(),
             ret_pc_segment: (return_pc.segment_index, 0).into(),
             builtin_segments,
             extra_segments,
+            simulated_builtins,
         };
 
         Ok(CairoPie {
@@ -1543,6 +1561,35 @@ impl CairoRunner {
             builtins_segments,
         })
     }
+
+    /// Loads builtin runners for simulated builtins in the pie's metadata, so the resulted pie is
+    /// compatible with the one received.
+    pub fn load_simulated_builtin_runners(
+        &mut self,
+        simulated_builtins: &[BuiltinName],
+    ) -> Result<(), CairoRunError> {
+        for builtin_name in simulated_builtins.iter() {
+            match builtin_name {
+                BuiltinName::ecdsa => {
+                    self.vm
+                        .simulated_builtin_runners
+                        .push(SignatureBuiltinRunner::new(Some(1), false).into());
+                }
+                BuiltinName::keccak => {
+                    self.vm
+                        .simulated_builtin_runners
+                        .push(KeccakBuiltinRunner::new(Some(1), false).into());
+                }
+                BuiltinName::ec_op => {
+                    self.vm
+                        .simulated_builtin_runners
+                        .push(EcOpBuiltinRunner::new(Some(1), false).into());
+                }
+                _ => return Err(CairoRunError::UnsupportedSimulatedBuiltin(*builtin_name)),
+            }
+        }
+        Ok(())
+    }
 }
 
 // TODO(Stav): move to specified file.
@@ -5729,4 +5776,49 @@ mod tests {
             deserialized_prover_input_info.public_memory_offsets
         );
     }
+
+    #[test]
+    fn test_load_simulated_builtin_runners_success() {
+        let program = Program::from_bytes(
+            include_bytes!("../../../../cairo_programs/fibonacci.json"),
+            Some("main"),
+        )
+        .unwrap();
+        let mut runner =
+            CairoRunner::new(&program, LayoutName::plain, None, false, false, false).unwrap();
+        runner.vm.simulated_builtin_runners.clear();
+
+        // Pass a slice with all supported simulated builtins.
+        runner
+            .load_simulated_builtin_runners(&[
+                BuiltinName::ecdsa,
+                BuiltinName::keccak,
+                BuiltinName::ec_op,
+            ])
+            .unwrap();
+
+        assert_eq!(runner.vm.simulated_builtin_runners.len(), 3);
+    }
+
+    #[test]
+    fn test_load_simulated_builtin_runners_failure() {
+        // Use a valid Cairo program to create a runner.
+        let program = Program::from_bytes(
+            include_bytes!("../../../../cairo_programs/fibonacci.json"),
+            Some("main"),
+        )
+        .unwrap();
+        let mut runner =
+            CairoRunner::new(&program, LayoutName::plain, None, false, false, false).unwrap();
+        runner.vm.simulated_builtin_runners.clear();
+
+        // Test with an unsupported simulated builtin.
+        let result = runner.load_simulated_builtin_runners(&[BuiltinName::pedersen]);
+        match result {
+            Err(CairoRunError::UnsupportedSimulatedBuiltin(builtin)) => {
+                assert_eq!(builtin, BuiltinName::pedersen);
+            }
+            _ => panic!("Expected unsupported simulated builtin error."),
+        }
+    }
 }