bootloader config: make applicative bootloader hash a list

Author: noam-starkware

.github/workflows/upload_artifacts_workflow.yml

@@ -3,7 +3,7 @@ name: Upload-Artifacts
 on:
   push:
     branches:
-      - noamp/applicative_bootloader_hints_extract_hash_func
+      - noamp/app_bl_hash_list_in_bl_cfg
 
 jobs:
   artifacts-push:

crates/cairo-program-runner-lib/src/hints/bootloader_hints.rs

@@ -158,12 +158,19 @@ pub fn load_bootloader_config(
         .map(|h| Box::new(MaybeRelocatable::from(h)) as Box<dyn Any>)
         .collect();
 
+    let supported_applicative_bootloader_hashes: Vec<Box<dyn Any>> = config
+        .applicative_bootloader_program_hash_list
+        .iter()
+        .map(|h| Box::new(MaybeRelocatable::from(h)) as Box<dyn Any>)
+        .collect();
+
     let args: Vec<Box<dyn Any>> = vec![
         maybe_relocatable_box!(config.supported_simple_bootloader_hash_list.len()),
         any_box!(supported_simple_bootloader_hashes),
         maybe_relocatable_box!(config.supported_cairo_verifier_program_hashes.len()),
         any_box!(supported_verifier_hashes),
-        maybe_relocatable_box!(config.applicative_bootloader_program_hash),
+        maybe_relocatable_box!(config.applicative_bootloader_program_hash_list.len()),
+        any_box!(supported_applicative_bootloader_hashes),
     ];
 
     // Store the args in the VM memory
@@ -316,14 +323,14 @@ pub fn compute_and_configure_fact_topologies(
     let output_builtin = vm.get_output_builtin_mut()?;
 
     let bootloader_input: BootloaderInput = exec_scopes.get(vars::BOOTLOADER_INPUT)?;
-    let applicative_bootloader_program_hash = bootloader_input
+    let applicative_bootloader_program_hash_list = bootloader_input
         .bootloader_config
-        .applicative_bootloader_program_hash;
+        .applicative_bootloader_program_hash_list;
 
     let plain_fact_topologies = compute_fact_topologies(
         &packed_outputs,
         &fact_topologies,
-        applicative_bootloader_program_hash,
+        applicative_bootloader_program_hash_list,
     )
     .map_err(Into::<HintError>::into)?;
 
@@ -520,7 +527,7 @@ mod tests {
                     Felt252::from(1234),
                     Felt252::from(5678),
                 ],
-                applicative_bootloader_program_hash: Felt252::from(2222),
+                applicative_bootloader_program_hash_list: vec![Felt252::from(2222)],
                 supported_cairo_verifier_program_hashes: vec![
                     Felt252::from(3333),
                     Felt252::from(4444),
@@ -699,7 +706,7 @@ mod tests {
         let config_segment = vm
             .segments
             .memory
-            .get_continuous_range(bootloader_config_segment, 5)
+            .get_continuous_range(bootloader_config_segment, 6)
             .unwrap();
 
         let simple_bootloader_hash_list_segment_len = match &config_segment[0] {
@@ -722,7 +729,16 @@ mod tests {
                 "Expected a relocatable value for cairo_verifier_program_hashes_segment_addr"
             ),
         };
-        let applicative_bootloader_program_hash = &config_segment[4];
+        let applicative_bootloader_program_hashes_segment_len = match &config_segment[4] {
+            MaybeRelocatable::Int(x) => (*x).to_usize().unwrap(),
+            _ => {
+                panic!("Expected an integer for applicative_bootloader_program_hashes_segment_len")
+            }
+        };
+        let applicative_bootloader_program_hashes_segment_addr = match &config_segment[5] {
+            MaybeRelocatable::RelocatableValue(relocatable) => relocatable,
+            _ => panic!("Expected a relocatable value for applicative_bootloader_program_hashes_segment_addr"),
+        };
 
         // Assert that the simple bootloader hash list segment length matches the expected length
         assert!(matches!(
@@ -766,11 +782,29 @@ mod tests {
             );
         }
 
+        // Assert that the applicative bootloader program hashes segment length matches the expected
+        // length
+        assert!(matches!(
+            applicative_bootloader_program_hashes_segment_len,
+            x if x == config.applicative_bootloader_program_hash_list.len()
+        ));
         // Assert that the applicative bootloader program hash matches the expected value
-        assert!(
-            matches!(applicative_bootloader_program_hash, MaybeRelocatable::Int(x) if *x ==
-            config.applicative_bootloader_program_hash)
-        );
+        let applicative_bootloader_program_hashes_segment = vm
+            .segments
+            .memory
+            .get_continuous_range(
+                *applicative_bootloader_program_hashes_segment_addr,
+                applicative_bootloader_program_hashes_segment_len,
+            )
+            .unwrap();
+        for (i, hash) in applicative_bootloader_program_hashes_segment
+            .iter()
+            .enumerate()
+        {
+            assert!(
+                matches!(hash, MaybeRelocatable::Int(x) if *x == config.applicative_bootloader_program_hash_list[i])
+            );
+        }
     }
 
     #[rstest]
@@ -951,7 +985,7 @@ mod tests {
             bootloader_config: BootloaderConfig {
                 supported_simple_bootloader_hash_list: vec![Felt252::from(1234)],
                 supported_cairo_verifier_program_hashes: Default::default(),
-                applicative_bootloader_program_hash: Felt252::from(2222),
+                applicative_bootloader_program_hash_list: vec![Felt252::from(2222)],
             },
             packed_outputs: packed_outputs.clone(),
         };

crates/cairo-program-runner-lib/src/hints/fact_topologies.rs

@@ -154,7 +154,7 @@ impl From<WriteFactTopologiesError> for HintError {
 pub fn compute_fact_topologies(
     packed_outputs: &Vec<PackedOutput>,
     fact_topologies: &Vec<FactTopology>,
-    applicative_bootloader_program_hash: Felt252,
+    applicative_bootloader_program_hash_list: Vec<Felt252>,
 ) -> Result<Vec<FactTopology>, FactTopologyError> {
     if packed_outputs.len() != fact_topologies.len() {
         return Err(FactTopologyError::WrongNumberOfFactTopologies(
@@ -172,7 +172,7 @@ pub fn compute_fact_topologies(
             }
             PackedOutput::Composite(composite_packed_output) => {
                 let subtask_plain_fact_topologies = composite_packed_output
-                    .get_plain_fact_topologies(applicative_bootloader_program_hash)
+                    .get_plain_fact_topologies(applicative_bootloader_program_hash_list.clone())
                     .map_err(|e| {
                         FactTopologyError::CompositePackedParsingFailed(
                             format!("{e:?}").into_boxed_str(),
@@ -493,11 +493,11 @@ mod tests {
         packed_outputs: Vec<PackedOutput>,
         fact_topologies: Vec<FactTopology>,
     ) {
-        let applicative_bootloader_program_hash = Felt252::from(1234);
+        let applicative_bootloader_program_hash_list = vec![Felt252::from(1234)];
         let plain_fact_topologies = compute_fact_topologies(
             &packed_outputs,
             &fact_topologies,
-            applicative_bootloader_program_hash,
+            applicative_bootloader_program_hash_list,
         )
         .expect("Failed to compute fact topologies");
         for (topology, plain_topology) in std::iter::zip(&fact_topologies, plain_fact_topologies) {
@@ -536,11 +536,11 @@ mod tests {
             tree_structure: vec![], // Not used for composite, but required by API
             page_sizes: vec![],
         }];
-        let applicative_bootloader_program_hash = Felt252::from(1234);
+        let applicative_bootloader_program_hash_list = vec![Felt252::from(1234)];
         let result = compute_fact_topologies(
             &packed_outputs,
             &fact_topologies,
-            applicative_bootloader_program_hash,
+            applicative_bootloader_program_hash_list,
         )
         .expect("Composite packed output should be supported and return subtask fact topologies");
 
@@ -562,11 +562,11 @@ mod tests {
     fn test_compute_fact_topologies_arg_len_mismatch() {
         let packed_outputs = vec![PackedOutput::Plain];
         let fact_topologies = vec![];
-        let applicative_bootloader_program_hash = Felt252::from(1234);
+        let applicative_bootloader_program_hash_list = vec![Felt252::from(1234)];
         let result = compute_fact_topologies(
             &packed_outputs,
             &fact_topologies,
-            applicative_bootloader_program_hash,
+            applicative_bootloader_program_hash_list,
         );
         assert!(
             matches!(result, Err(FactTopologyError::WrongNumberOfFactTopologies(n_outputs, n_topologies)) if n_outputs == packed_outputs.len() && n_topologies == fact_topologies.len())

crates/cairo-program-runner-lib/src/hints/types.rs

@@ -30,7 +30,7 @@ pub(crate) type ProgramIdentifiers = HashMap<String, Identifier>;
 #[derive(Deserialize, Debug, Clone)]
 pub struct BootloaderConfig {
     pub supported_simple_bootloader_hash_list: Vec<Felt252>,
-    pub applicative_bootloader_program_hash: Felt252,
+    pub applicative_bootloader_program_hash_list: Vec<Felt252>,
     pub supported_cairo_verifier_program_hashes: Vec<Felt252>,
 }
 
@@ -72,7 +72,7 @@ impl CompositePackedOutput {
     /// * Returns an error if the sum of subtask sizes does not match the length of `outputs`.
     pub fn get_plain_fact_topologies(
         &self,
-        applicative_bootloader_program_hash: Felt252,
+        applicative_bootloader_program_hash_list: Vec<Felt252>,
     ) -> Result<Vec<FactTopology>, String> {
         let mut subtasks_fact_topologies = Vec::new();
 
@@ -111,7 +111,7 @@ impl CompositePackedOutput {
             // Handle subtask if it is of type `PackedOutput::Plain`
             if let PackedOutput::Plain = subtask {
                 // If the program hash matches the app. bootloader hash, adjust the page sizes
-                if *program_hash == applicative_bootloader_program_hash {
+                if applicative_bootloader_program_hash_list.contains(program_hash) {
                     let mut page_sizes = self.fact_topologies[index].page_sizes.clone();
                     if let Some(first_page_size) = page_sizes.get_mut(0) {
                         *first_page_size -= applicative_bootloader_header_size;
@@ -128,7 +128,9 @@ impl CompositePackedOutput {
             // Handle subtask recursively if it is of type `PackedOutput::Composite`
             else if let PackedOutput::Composite(composite) = subtask {
                 subtasks_fact_topologies.extend(
-                    composite.get_plain_fact_topologies(applicative_bootloader_program_hash)?,
+                    composite.get_plain_fact_topologies(
+                        applicative_bootloader_program_hash_list.clone(),
+                    )?,
                 );
             } else {
                 return Err("Unsupported subtask type".to_string());