apollo_starknet_os_program: implement calculate_block_hash

Author: Yoni-Starkware

crates/apollo_starknet_os_program/src/cairo/starkware/starknet/core/os/block_hash.cairo

@@ -0,0 +1,50 @@
+from starkware.cairo.common.cairo_builtins import PoseidonBuiltin
+from starkware.cairo.common.hash_state_poseidon import (
+    HashState,
+    hash_init,
+    hash_finalize,
+    hash_update_single,
+)
+from starkware.starknet.common.new_syscalls import BlockInfo
+
+// The latest block hash version.
+const BLOCK_HASH_VERSION = 'STARKNET_BLOCK_HASH1';
+
+struct BlockHeaderCommitments {
+    transaction_commitment: felt,
+    event_commitment: felt,
+    receipt_commitment: felt,
+    state_diff_commitment: felt,
+    concatenated_counts: felt,
+}
+
+// Calculates the block hash given the top level components.
+func calculate_block_hash{poseidon_ptr: PoseidonBuiltin*}(
+    block_info: BlockInfo*,
+    header_commitments: BlockHeaderCommitments*,
+    gas_prices_hash: felt,
+    state_root: felt,
+    parent_hash: felt,
+    starknet_version: felt,
+) -> felt {
+    let hash_state = hash_init();
+    with hash_state {
+        hash_update_single(BLOCK_HASH_VERSION);
+        hash_update_single(block_info.block_number);
+        hash_update_single(state_root);
+        hash_update_single(block_info.sequencer_address);
+        hash_update_single(block_info.block_timestamp);
+        hash_update_single(header_commitments.concatenated_counts);
+        hash_update_single(header_commitments.state_diff_commitment);
+        hash_update_single(header_commitments.transaction_commitment);
+        hash_update_single(header_commitments.event_commitment);
+        hash_update_single(header_commitments.receipt_commitment);
+        hash_update_single(gas_prices_hash);
+        hash_update_single(starknet_version);
+        hash_update_single(0);
+        hash_update_single(parent_hash);
+    }
+
+    let block_hash = hash_finalize(hash_state=hash_state);
+    return block_hash;
+}

crates/starknet_api/src/block_hash/block_hash_calculator.rs

@@ -33,10 +33,10 @@ mod block_hash_calculator_test;
 static STARKNET_BLOCK_HASH0: LazyLock<Felt> = LazyLock::new(|| {
     ascii_as_felt("STARKNET_BLOCK_HASH0").expect("ascii_as_felt failed for 'STARKNET_BLOCK_HASH0'")
 });
-static STARKNET_BLOCK_HASH1: LazyLock<Felt> = LazyLock::new(|| {
+pub static STARKNET_BLOCK_HASH1: LazyLock<Felt> = LazyLock::new(|| {
     ascii_as_felt("STARKNET_BLOCK_HASH1").expect("ascii_as_felt failed for 'STARKNET_BLOCK_HASH1'")
 });
-static STARKNET_GAS_PRICES0: LazyLock<Felt> = LazyLock::new(|| {
+pub static STARKNET_GAS_PRICES0: LazyLock<Felt> = LazyLock::new(|| {
     ascii_as_felt("STARKNET_GAS_PRICES0").expect("ascii_as_felt failed for 'STARKNET_GAS_PRICES0'")
 });
 
@@ -261,7 +261,7 @@ fn to_64_bits(num: usize) -> [u8; 8] {
 // Otherwise, returns:
 // [gas_price_wei, gas_price_fri, data_gas_price_wei, data_gas_price_fri].
 // TODO(Ayelet): add l2_gas_consumed, next_l2_gas_price after 0.14.0.
-fn gas_prices_to_hash(
+pub fn gas_prices_to_hash(
     l1_gas_price: &GasPricePerToken,
     l1_data_gas_price: &GasPricePerToken,
     l2_gas_price: &GasPricePerToken,

crates/starknet_os/src/hints/hint_implementation.rs

@@ -1,6 +1,7 @@
 pub(crate) mod aggregator;
 pub(crate) mod blake2s;
 pub(crate) mod block_context;
+pub(crate) mod block_hash;
 pub(crate) mod bls_field;
 pub(crate) mod builtins;
 pub(crate) mod cairo1_revert;

crates/starknet_os/src/hints/hint_implementation/block_hash.rs

@@ -0,0 +1,2 @@
+#[cfg(test)]
+mod test;

crates/starknet_os/src/hints/hint_implementation/block_hash/test.rs

@@ -0,0 +1,191 @@
+use std::collections::HashMap;
+use std::sync::LazyLock;
+
+use apollo_infra_utils::cairo0_compiler::compile_cairo0_program;
+use cairo_vm::types::builtin_name::BuiltinName;
+use cairo_vm::types::layout_name::LayoutName;
+use cairo_vm::types::program::Program;
+use cairo_vm::types::relocatable::MaybeRelocatable;
+use rstest::rstest;
+use starknet_api::block::{
+    BlockHash,
+    BlockNumber,
+    BlockTimestamp,
+    GasPrice,
+    GasPricePerToken,
+    StarknetVersion,
+};
+use starknet_api::block_hash::block_hash_calculator::{
+    calculate_block_hash,
+    gas_prices_to_hash,
+    BlockHashVersion,
+    BlockHeaderCommitments,
+    PartialBlockHashComponents,
+    STARKNET_BLOCK_HASH1,
+};
+use starknet_api::core::{
+    ascii_as_felt,
+    EventCommitment,
+    GlobalRoot,
+    ReceiptCommitment,
+    SequencerContractAddress,
+    StateDiffCommitment,
+    TransactionCommitment,
+};
+use starknet_api::hash::PoseidonHash;
+use starknet_types_core::felt::Felt;
+
+use crate::test_utils::cairo_runner::{
+    initialize_cairo_runner,
+    run_cairo_0_entrypoint,
+    EndpointArg,
+    EntryPointRunnerConfig,
+    ImplicitArg,
+    PointerArg,
+    ValueArg,
+};
+
+// TODO(Yoni): use the OS program bytes instead once the block hash is reachable by the OS.
+static BLOCK_HASH_PROGRAM_BYTES: LazyLock<Vec<u8>> = LazyLock::new(|| {
+    let cairo_root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+        .join("../../crates/apollo_starknet_os_program/src/cairo")
+        .canonicalize()
+        .unwrap();
+    let block_hash_file = cairo_root.join("starkware/starknet/core/os/block_hash.cairo");
+    compile_cairo0_program(block_hash_file, cairo_root).expect("Failed to compile cairo0 program")
+});
+static BLOCK_HASH_PROGRAM: LazyLock<Program> = LazyLock::new(|| {
+    cairo_vm::types::program::Program::from_bytes(&BLOCK_HASH_PROGRAM_BYTES, None)
+        .expect("Failed to load program")
+});
+
+fn cairo_calculate_block_hash(
+    components: &PartialBlockHashComponents,
+    state_root: Felt,
+    parent_hash: Felt,
+) -> Felt {
+    let runner_config = EntryPointRunnerConfig {
+        layout: LayoutName::starknet,
+        add_main_prefix_to_entrypoint: true, // It's the main file now
+        ..Default::default()
+    };
+
+    let implicit_args = vec![ImplicitArg::Builtin(BuiltinName::poseidon)];
+    let (mut runner, program, entrypoint) = initialize_cairo_runner(
+        &runner_config,
+        &BLOCK_HASH_PROGRAM_BYTES,
+        "calculate_block_hash",
+        &implicit_args,
+        HashMap::new(),
+    )
+    .expect("Failed to initialize cairo runner");
+
+    let block_info_arg = EndpointArg::Pointer(PointerArg::Array(vec![
+        Felt::from(components.block_number.0).into(),
+        Felt::from(components.timestamp.0).into(),
+        components.sequencer.0.0.key().into(),
+    ]));
+
+    let header_commitments_arg = EndpointArg::Pointer(PointerArg::Array(vec![
+        components.header_commitments.transaction_commitment.0.into(),
+        components.header_commitments.event_commitment.0.into(),
+        components.header_commitments.receipt_commitment.0.into(),
+        components.header_commitments.state_diff_commitment.0.0.into(),
+        components.header_commitments.concatenated_counts.into(),
+    ]));
+
+    let [gas_prices_hash]: [Felt; 1] = gas_prices_to_hash(
+        &components.l1_gas_price,
+        &components.l1_data_gas_price,
+        &components.l2_gas_price,
+        &components.starknet_version.try_into().unwrap(),
+    )
+    .try_into()
+    .expect("gas_prices_to_hash should return a single felt");
+
+    let explicit_args = vec![
+        block_info_arg,
+        header_commitments_arg,
+        EndpointArg::from(gas_prices_hash),
+        EndpointArg::from(state_root),
+        EndpointArg::from(parent_hash),
+        EndpointArg::from(ascii_as_felt(&components.starknet_version.to_string()).unwrap()),
+    ];
+
+    // We expect one felt as return value (block_hash).
+    let expected_explicit_return_values = vec![EndpointArg::from(0)];
+
+    let (_, explicit_return_values, _) = run_cairo_0_entrypoint(
+        entrypoint,
+        &explicit_args,
+        &implicit_args,
+        None,
+        &mut runner,
+        &program,
+        &runner_config,
+        &expected_explicit_return_values,
+    )
+    .expect("Failed to run cairo entrypoint");
+
+    match &explicit_return_values[0] {
+        EndpointArg::Value(ValueArg::Single(MaybeRelocatable::Int(val))) => *val,
+        _ => panic!("Unexpected return value type: {:?}", explicit_return_values[0]),
+    }
+}
+
+#[rstest]
+fn test_block_hash_cairo() {
+    let components = PartialBlockHashComponents {
+        block_number: BlockNumber(1),
+        timestamp: BlockTimestamp(2),
+        sequencer: SequencerContractAddress(Felt::from(3).try_into().unwrap()),
+        header_commitments: BlockHeaderCommitments {
+            transaction_commitment: TransactionCommitment(Felt::from(4)),
+            event_commitment: EventCommitment(Felt::from(5)),
+            receipt_commitment: ReceiptCommitment(Felt::from(6)),
+            state_diff_commitment: StateDiffCommitment(PoseidonHash(Felt::from(7))),
+            concatenated_counts: Felt::from(8),
+        },
+        l1_gas_price: GasPricePerToken { price_in_wei: GasPrice(10), price_in_fri: GasPrice(11) },
+        l1_data_gas_price: GasPricePerToken {
+            price_in_wei: GasPrice(12),
+            price_in_fri: GasPrice(13),
+        },
+        l2_gas_price: GasPricePerToken { price_in_wei: GasPrice(14), price_in_fri: GasPrice(15) },
+        starknet_version: StarknetVersion::LATEST,
+    };
+    let state_root = Felt::from(16);
+    let parent_hash = Felt::from(17);
+
+    let cairo_hash = cairo_calculate_block_hash(&components, state_root, parent_hash);
+
+    let expected_hash =
+        calculate_block_hash(&components, GlobalRoot(state_root), BlockHash(parent_hash))
+            .unwrap()
+            .0;
+
+    assert_eq!(cairo_hash, expected_hash);
+}
+
+#[rstest]
+fn test_block_hash_version() {
+    let (_, cairo_block_hash_version_felt) = BLOCK_HASH_PROGRAM
+        .constants
+        .iter()
+        .find(|(name, _)| name.ends_with("BLOCK_HASH_VERSION"))
+        .unwrap();
+
+    let latest_block_hash_version: Felt =
+        BlockHashVersion::try_from(StarknetVersion::LATEST).unwrap().into();
+
+    // NOTE: if these checks fail, it means the block hash version in the OS program is not the
+    // latest, and a backward-compatibility flow must be added for the transition.
+    assert_eq!(
+        *STARKNET_BLOCK_HASH1, latest_block_hash_version,
+        "Latest block hash version constant mismatch"
+    );
+    assert_eq!(
+        *cairo_block_hash_version_felt, latest_block_hash_version,
+        "Cairo BLOCK_HASH_VERSION constant mismatch"
+    );
+}