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

Author: dorimedini-starkware

crates/apollo_starknet_os_program/build/compile_program.rs

@@ -3,11 +3,8 @@ use std::path::PathBuf;
 use apollo_infra_utils::cairo0_compiler::{compile_cairo0_program, Cairo0CompilerError};
 use apollo_infra_utils::compile_time_cargo_manifest_dir;
 
-/// Compile the StarkNet OS program.
-pub fn compile_starknet_os() -> Vec<u8> {
-    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");
-    match compile_cairo0_program(os_main_path, cairo_root_path) {
+fn compile_program(path_to_main_file: PathBuf) -> Vec<u8> {
+    match compile_cairo0_program(path_to_main_file, cairo_root_path()) {
         Ok(bytes) => bytes,
         Err(Cairo0CompilerError::Cairo0CompilerVersion(error)) => {
             panic!(
@@ -18,7 +15,19 @@ pub fn compile_starknet_os() -> Vec<u8> {
             )
         }
         Err(other_error) => {
-            panic!("Failed to compile the StarkNet OS program. Error:\n{other_error}.")
+            panic!("Failed to compile the program. Error:\n{other_error}.")
         }
     }
 }
+
+fn cairo_root_path() -> PathBuf {
+    PathBuf::from(compile_time_cargo_manifest_dir!()).join("src/cairo")
+}
+
+pub fn compile_starknet_os() -> Vec<u8> {
+    compile_program(cairo_root_path().join("starkware/starknet/core/os/os.cairo"))
+}
+
+pub fn compile_starknet_aggregator() -> Vec<u8> {
+    compile_program(cairo_root_path().join("starkware/starknet/core/aggregator/main.cairo"))
+}

crates/apollo_starknet_os_program/build/main.rs

@@ -19,4 +19,11 @@ fn main() {
     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_program::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.");
 }

crates/apollo_starknet_os_program/src/lib.rs

@@ -16,10 +16,16 @@ pub static CAIRO_FILES_MAP: LazyLock<HashMap<String, String>> = LazyLock::new(||
 });
 
 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": "0x44a93b0a0bed63f4c3ca30418dff64aed464ce2cf1e9cad25624f540cac27c8"
-}
+  "os": "0x44a93b0a0bed63f4c3ca30418dff64aed464ce2cf1e9cad25624f540cac27c8",
+  "aggregator": "0x181986bfe23bbfdac56c40522bd5c2b1b64c824c74bd6722a3ccacc8cc888e2",
+  "aggregator_with_prefix": "0x1ae51bd7157e0754f1e1729806ad5579a7ac6926cd0c8dd342ad1e7a3758c2e"
+}

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(),