feat(apollo_starknet_os_program): define and implement static ProgramHash

Author: dorimedini-starkware

Cargo.lock

@@ -11,6 +11,10 @@ workspace = true
 
 [dependencies]
 cairo-vm.workspace = true
+serde = { workspace = true, features = ["derive"] }
+serde_json.workspace = true
+starknet-types-core.workspace = true
+thiserror.workspace = true
 
 [build-dependencies]
 apollo_infra_utils.workspace = true

crates/apollo_starknet_os_program/Cargo.toml

@@ -2,10 +2,19 @@ use std::sync::LazyLock;
 
 use cairo_vm::types::program::Program;
 
+use crate::program_hash::ProgramHash;
+
+pub mod program_hash;
+
 pub const OS_PROGRAM: LazyLock<Program> = LazyLock::new(|| {
     Program::from_bytes(
         include_bytes!(concat!(env!("OUT_DIR"), "/starknet_os_bytes")),
         Some("main"),
     )
     .expect("Failed to load the OS bytes.")
 });
+
+pub const PROGRAM_HASH: LazyLock<ProgramHash> = LazyLock::new(|| {
+    serde_json::from_str(include_str!("program_hash.json"))
+        .expect("Failed to deserialize program_hash.json.")
+});

crates/apollo_starknet_os_program/src/lib.rs

@@ -0,0 +1,3 @@
+{
+    "os": "0x4c87691af69c8633ceab827eadea0374d645e315fe69c0ed3ec55803b3fbf0a"
+}

crates/apollo_starknet_os_program/src/program_hash.json

@@ -0,0 +1,72 @@
+use cairo_vm::types::builtin_name::BuiltinName;
+use cairo_vm::types::errors::program_errors::ProgramError;
+use serde::{Deserialize, Serialize};
+use starknet_types_core::felt::Felt;
+use starknet_types_core::hash::{Pedersen, StarkHash};
+
+use crate::OS_PROGRAM;
+
+#[cfg(test)]
+#[path = "program_hash_test.rs"]
+pub mod test;
+
+#[derive(thiserror::Error, Debug)]
+pub enum ProgramHashError {
+    #[error("Builtin name is too long: {0}.")]
+    BuiltinNameTooLong(BuiltinName),
+    #[error(transparent)]
+    Program(#[from] ProgramError),
+    #[error("Program data contains unexpected relocatable.")]
+    UnexpectedRelocatable,
+}
+
+#[derive(Deserialize, Serialize)]
+pub struct ProgramHash {
+    os: Felt,
+}
+
+const BOOTLOADER_VERSION: u8 = 0;
+
+fn pedersen_hash_chain(data: Vec<Felt>) -> Felt {
+    let length = Felt::from(data.len());
+    vec![length]
+        .into_iter()
+        .chain(data.into_iter())
+        .rev()
+        .reduce(|x, y| Pedersen::hash(&y, &x))
+        .expect("Hash data chain is not empty.")
+}
+
+pub fn compute_os_program_hash() -> Result<Felt, ProgramHashError> {
+    let builtins = OS_PROGRAM
+        .iter_builtins()
+        .map(|builtin| {
+            let builtin_bytes = builtin.to_str().to_string().into_bytes();
+            if builtin_bytes.len() > 32 {
+                Err(ProgramHashError::BuiltinNameTooLong(builtin.clone()))
+            } else {
+                let mut padded_builtin_bytes = vec![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."),
+                ))
+            }
+        })
+        .collect::<Result<Vec<Felt>, _>>()?;
+    let program_header = vec![
+        Felt::from(BOOTLOADER_VERSION),
+        Felt::from(OS_PROGRAM.get_stripped_program()?.main),
+        Felt::from(builtins.len()),
+    ];
+    let data = OS_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.into_iter()).chain(data.into_iter()).collect();
+    Ok(pedersen_hash_chain(data_chain))
+}

crates/apollo_starknet_os_program/src/program_hash.rs

@@ -0,0 +1,7 @@
+use crate::program_hash::compute_os_program_hash;
+use crate::PROGRAM_HASH;
+
+#[test]
+fn test_program_hash() {
+    assert_eq!(compute_os_program_hash().unwrap(), PROGRAM_HASH.os)
+}