feat(apollo_starknet_os_program): add aggregator program + program hash(es)

Author: dorimedini-starkware

crates/apollo_starknet_os_program/build.rs

@@ -7,33 +7,46 @@ use apollo_infra_utils::compile_time_cargo_manifest_dir;
 /// Build script for the `apollo_starknet_os_program` crate.
 /// Recompiles the OS program if the source files change.
 fn main() {
-    let out_dir = std::env::var("OUT_DIR").expect("OUT_DIR not set.");
+    let out_dir = PathBuf::from(std::env::var("OUT_DIR").expect("OUT_DIR not set."));
+
     println!("cargo::warning=Compiling Starknet OS program...");
     let starknet_os_bytes = compile_starknet_os();
     println!("cargo::warning=Done. Writing compiled bytes to output directory.");
-    let starknet_os_bytes_path = PathBuf::from(out_dir).join("starknet_os_bytes");
+    let starknet_os_bytes_path = out_dir.join("starknet_os_bytes");
     std::fs::write(&starknet_os_bytes_path, &starknet_os_bytes)
         .expect("Failed to write the compiled OS bytes to the output directory.");
+
+    println!("cargo::warning=Compiling Starknet aggregator program...");
+    let starknet_aggregator_bytes = compile_starknet_aggregator();
+    println!("cargo::warning=Done. Writing compiled bytes to output directory.");
+    let starknet_aggregator_bytes_path = out_dir.join("starknet_aggregator_bytes");
+    std::fs::write(&starknet_aggregator_bytes_path, &starknet_aggregator_bytes)
+        .expect("Failed to write the compiled aggregator bytes to the output directory.");
 }
 
-/// Compile the StarkNet OS program.
-fn compile_starknet_os() -> Vec<u8> {
+fn cairo_root_path() -> PathBuf {
+    PathBuf::from(compile_time_cargo_manifest_dir!()).join("src/cairo")
+}
+
+/// Compile a StarkNet program.
+fn compile_starknet_program(path_to_main_file: PathBuf) -> Vec<u8> {
     cairo0_compilers_correct_version().unwrap_or_else(|error| {
         panic!(
             "Failed to verify correct cairo0 package installation. Please make sure you do not \
              have a conflicting installation in your {}/bin directory.\nOriginal error: {error:?}.",
             std::env::var("CARGO_HOME").unwrap_or("${CARGO_HOME}".to_string())
         )
     });
-    let cairo_root_path = PathBuf::from(compile_time_cargo_manifest_dir!()).join("src/cairo");
-    let os_main_path = cairo_root_path.join("starkware/starknet/core/os/os.cairo");
-    assert!(os_main_path.exists(), "OS main file does not exist at {os_main_path:?}.");
+    assert!(
+        path_to_main_file.exists(),
+        "Main program file does not exist at {path_to_main_file:?}."
+    );
     let mut compile_os_command = Command::new(CAIRO0_COMPILE);
     compile_os_command.args([
-        os_main_path.to_str().expect("Path is valid unicode."),
+        path_to_main_file.to_str().expect("Path is valid unicode."),
         "--debug_info_with_source",
         "--cairo_path",
-        cairo_root_path.to_str().expect("Path to cairo is valid unicode."),
+        cairo_root_path().to_str().expect("Path to cairo is valid unicode."),
     ]);
     println!("cargo::warning=Running command {compile_os_command:?}.");
     let compile_os_output =
@@ -47,3 +60,13 @@ fn compile_starknet_os() -> Vec<u8> {
 
     compile_os_output.stdout
 }
+
+fn compile_starknet_os() -> Vec<u8> {
+    compile_starknet_program(cairo_root_path().join("starkware/starknet/core/os/os.cairo"))
+}
+
+fn compile_starknet_aggregator() -> Vec<u8> {
+    compile_starknet_program(
+        cairo_root_path().join("starkware/starknet/core/aggregator/main.cairo"),
+    )
+}

crates/apollo_starknet_os_program/src/lib.rs

@@ -8,10 +8,16 @@ use crate::program_hash::{ProgramHash, PROGRAM_HASH_PATH};
 pub mod program_hash;
 
 pub const OS_PROGRAM_BYTES: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/starknet_os_bytes"));
+pub const AGGREGATOR_PROGRAM_BYTES: &[u8] =
+    include_bytes!(concat!(env!("OUT_DIR"), "/starknet_aggregator_bytes"));
 
 pub static OS_PROGRAM: LazyLock<Program> = LazyLock::new(|| {
     Program::from_bytes(OS_PROGRAM_BYTES, Some("main")).expect("Failed to load the OS bytes.")
 });
+pub static AGGREGATOR_PROGRAM: LazyLock<Program> = LazyLock::new(|| {
+    Program::from_bytes(AGGREGATOR_PROGRAM_BYTES, Some("main"))
+        .expect("Failed to load the aggregator bytes.")
+});
 
 pub static PROGRAM_HASH: LazyLock<ProgramHash> = LazyLock::new(|| {
     serde_json::from_reader(

crates/apollo_starknet_os_program/src/program_hash.json

@@ -1,3 +1,5 @@
 {
-  "os": "0x588ec9f078983180b2027b9cdf264cbd1cd6ddf2ca3f3cfabd305f4c7112288"
+  "os": "0x588ec9f078983180b2027b9cdf264cbd1cd6ddf2ca3f3cfabd305f4c7112288",
+  "aggregator": "0x30925cb9d051953287ecc2324890442fc41b2e24ef96287158ce3873e34e579",
+  "aggregator_with_prefix": "0x32ff44735759337ba12dd15b456dc30f64e0ba618b3cf888b267ebfa6de892"
 }

crates/apollo_starknet_os_program/src/program_hash.rs

@@ -4,11 +4,12 @@ use std::sync::LazyLock;
 use apollo_infra_utils::compile_time_cargo_manifest_dir;
 use cairo_vm::types::builtin_name::BuiltinName;
 use cairo_vm::types::errors::program_errors::ProgramError;
+use cairo_vm::types::program::Program;
 use serde::{Deserialize, Serialize};
 use starknet_types_core::felt::Felt;
 use starknet_types_core::hash::{Pedersen, StarkHash};
 
-use crate::OS_PROGRAM;
+use crate::{AGGREGATOR_PROGRAM, OS_PROGRAM};
 
 #[cfg(test)]
 #[path = "program_hash_test.rs"]
@@ -31,10 +32,27 @@ pub(crate) static PROGRAM_HASH_PATH: LazyLock<PathBuf> = LazyLock::new(|| {
 #[derive(Debug, Deserialize, Serialize, PartialEq)]
 pub struct ProgramHash {
     pub os: Felt,
+    pub aggregator: Felt,
+    pub aggregator_with_prefix: Felt,
+}
+
+pub struct AggregatorHash {
+    pub with_prefix: Felt,
+    pub without_prefix: Felt,
 }
 
 const BOOTLOADER_VERSION: u8 = 0;
 
+fn pad_to_32_bytes(data: &[u8]) -> [u8; 32] {
+    let mut padded = [0; 32];
+    let len = data.len();
+    if len > 32 {
+        panic!("Data length exceeds 32 bytes.");
+    }
+    padded[32 - len..].copy_from_slice(data);
+    padded
+}
+
 fn pedersen_hash_chain(data: Vec<Felt>) -> Felt {
     let length = Felt::from(data.len());
     vec![length]
@@ -45,35 +63,40 @@ fn pedersen_hash_chain(data: Vec<Felt>) -> Felt {
         .expect("Hash data chain is not empty.")
 }
 
-pub fn compute_os_program_hash() -> Result<Felt, ProgramHashError> {
-    let builtins = OS_PROGRAM
+fn compute_program_hash(program: &Program) -> Result<Felt, ProgramHashError> {
+    let builtins = program
         .iter_builtins()
         .map(|builtin| {
             let builtin_bytes = builtin.to_str().to_string().into_bytes();
             if builtin_bytes.len() > 32 {
                 Err(ProgramHashError::BuiltinNameTooLong(*builtin))
             } else {
-                let mut padded_builtin_bytes = [0].repeat(32 - builtin_bytes.len());
-                padded_builtin_bytes.extend(builtin_bytes);
-                Ok(Felt::from_bytes_be(
-                    padded_builtin_bytes
-                        .as_slice()
-                        .try_into()
-                        .expect("Padded bytes are 32 bytes long."),
-                ))
+                Ok(Felt::from_bytes_be(&pad_to_32_bytes(&builtin_bytes)))
             }
         })
         .collect::<Result<Vec<Felt>, _>>()?;
     let program_header = vec![
         Felt::from(BOOTLOADER_VERSION),
-        Felt::from(OS_PROGRAM.get_stripped_program()?.main),
+        Felt::from(program.get_stripped_program()?.main),
         Felt::from(builtins.len()),
     ];
-    let data = OS_PROGRAM
+    let data = program
         .iter_data()
         .map(|data| data.get_int().ok_or(ProgramHashError::UnexpectedRelocatable))
         .collect::<Result<Vec<Felt>, _>>()?;
 
     let data_chain: Vec<Felt> = program_header.into_iter().chain(builtins).chain(data).collect();
     Ok(pedersen_hash_chain(data_chain))
 }
+
+pub fn compute_os_program_hash() -> Result<Felt, ProgramHashError> {
+    compute_program_hash(&OS_PROGRAM)
+}
+
+pub fn compute_aggregator_program_hash() -> Result<AggregatorHash, ProgramHashError> {
+    let hash = compute_program_hash(&AGGREGATOR_PROGRAM)?;
+    Ok(AggregatorHash {
+        with_prefix: Pedersen::hash(&Felt::from_bytes_be(&pad_to_32_bytes(b"AGGREGATOR")), &hash),
+        without_prefix: hash,
+    })
+}

crates/apollo_starknet_os_program/src/program_hash_test.rs

@@ -1,4 +1,10 @@
-use crate::program_hash::{compute_os_program_hash, ProgramHash, PROGRAM_HASH_PATH};
+use crate::program_hash::{
+    compute_aggregator_program_hash,
+    compute_os_program_hash,
+    AggregatorHash,
+    ProgramHash,
+    PROGRAM_HASH_PATH,
+};
 use crate::PROGRAM_HASH;
 
 /// Asserts the program hash of the compiled Starknet OS program matches the program hash in the
@@ -9,7 +15,12 @@ use crate::PROGRAM_HASH;
 /// ```
 #[test]
 fn test_program_hash() {
-    let computed_hash = ProgramHash { os: compute_os_program_hash().unwrap() };
+    let AggregatorHash { with_prefix, without_prefix } = compute_aggregator_program_hash().unwrap();
+    let computed_hash = ProgramHash {
+        os: compute_os_program_hash().unwrap(),
+        aggregator: without_prefix,
+        aggregator_with_prefix: with_prefix,
+    };
     if std::env::var("FIX_PROGRAM_HASH").is_ok() {
         std::fs::write(
             PROGRAM_HASH_PATH.as_path(),