starknet_api: add fee_proposal_fri to block hash calculator

Author: sirandreww-starkware

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

@@ -3,7 +3,7 @@ from starkware.cairo.common.hash_state_poseidon import hash_finalize, hash_init,
 from starkware.starknet.common.new_syscalls import BlockInfo
 
 // The latest block hash version.
-const BLOCK_HASH_VERSION = 'STARKNET_BLOCK_HASH1';
+const BLOCK_HASH_VERSION = 'STARKNET_BLOCK_HASH2';
 
 struct BlockHeaderCommitments {
     transaction_commitment: felt,
@@ -20,6 +20,7 @@ func calculate_block_hash{poseidon_ptr: PoseidonBuiltin*}(
     block_info: BlockInfo*,
     header_commitments: BlockHeaderCommitments*,
     gas_prices_hash: felt,
+    fee_proposal_fri: felt,
     state_root: felt,
     previous_block_hash: felt,
     starknet_version: felt,
@@ -40,6 +41,8 @@ func calculate_block_hash{poseidon_ptr: PoseidonBuiltin*}(
         hash_update_single(header_commitments.event_commitment);
         hash_update_single(header_commitments.receipt_commitment);
         hash_update_single(gas_prices_hash);
+        // SNIP-35: include the proposer's recommended fee.
+        hash_update_single(fee_proposal_fri);
         hash_update_single(starknet_version);
         hash_update_single(0);
         hash_update_single(previous_block_hash);
@@ -67,10 +70,12 @@ func get_block_hashes{poseidon_ptr: PoseidonBuiltin*}(block_info: BlockInfo*, st
 
     %{ GetBlockHashes %}
 
+    // TODO(SNIP-35): plumb the proposer's fee_proposal_fri through the OS input.
     let block_hash = calculate_block_hash(
         block_info=block_info,
         header_commitments=header_commitments,
         gas_prices_hash=gas_prices_hash,
+        fee_proposal_fri=0,
         state_root=state_root,
         previous_block_hash=previous_block_hash,
         starknet_version=starknet_version,

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

@@ -66,7 +66,7 @@ const STORED_BLOCK_HASH_BUFFER = 10;
 
 // Allowed virtual OS program hashes for client-side proving.
 const ALLOWED_VIRTUAL_OS_PROGRAM_HASHES_0 = (
-    0x03e98c2d7703b03a7edb73ed7f075f97f1dcbaa8f717cdf6e1a57bf058265473
+    0x0576598b6f9b53f0c0b5703eec1c9da47c4717aca88acfe88133c626a33ce3c2
 );
 const ALLOWED_VIRTUAL_OS_PROGRAM_HASHES_LEN = 1;
 

crates/apollo_starknet_os_program/src/program_hash.json

@@ -1,6 +1,6 @@
 {
-  "os": "0xb0134eed363da4094afca019a74939b4c17f238a4f7411798813f55905cd7",
-  "virtual_os": "0x3e98c2d7703b03a7edb73ed7f075f97f1dcbaa8f717cdf6e1a57bf058265473",
+  "os": "0x1c8fb6fff3a785dafb6567f1b3b22a2512ac7095bcb00e531c02ced345febe4",
+  "virtual_os": "0x576598b6f9b53f0c0b5703eec1c9da47c4717aca88acfe88133c626a33ce3c2",
   "aggregator": "0x43666b81f964bcdedf0098d2791b061d61f3098ff1429a754d0b97eeeae9489",
   "aggregator_with_prefix": "0x68072c8f5ff5ae133060e12cfad3a38362dbb6d667abd4f7e1fac6f37febe46"
 }

crates/apollo_starknet_os_program/src/virtual_os_test.rs

@@ -19,11 +19,11 @@ fn test_virtual_os_swapped_files() {
 #[test]
 fn test_program_bytecode_lengths() {
     expect![[r#"
-        15610
+        15615
     "#]]
     .assert_debug_eq(&OS_PROGRAM.data_len());
     expect![[r#"
-        10214
+        10219
     "#]]
     .assert_debug_eq(&VIRTUAL_OS_PROGRAM.data_len());
 }

crates/blockifier/resources/blockifier_versioned_constants_0_14_3.json

@@ -67,7 +67,7 @@
     "segment_arena_cells": false,
     "os_constants": {
         "allowed_virtual_os_program_hashes": [
-            "0x3e98c2d7703b03a7edb73ed7f075f97f1dcbaa8f717cdf6e1a57bf058265473"
+            "0x576598b6f9b53f0c0b5703eec1c9da47c4717aca88acfe88133c626a33ce3c2"
         ],
         "constructor_entry_point_selector": "0x28ffe4ff0f226a9107253e17a904099aa4f63a02a5621de0576e5aa71bc5194",
         "default_entry_point_selector": "0x0",

crates/blockifier/resources/versioned_constants_diff_regression/0.14.2_0.14.3.txt

@@ -1 +1 @@
-
+~ /os_constants/allowed_virtual_os_program_hashes/0: "0x576598b6f9b53f0c0b5703eec1c9da47c4717aca88acfe88133c626a33ce3c2"

crates/starknet_api/src/block_hash/block_hash_calculator.rs

@@ -42,12 +42,18 @@ use crate::{StarknetApiError, StarknetApiResult};
 #[path = "block_hash_calculator_test.rs"]
 mod block_hash_calculator_test;
 
-static STARKNET_BLOCK_HASH0: LazyLock<Felt> = LazyLock::new(|| {
+// The prefix constant for the block hash calculation.
+type BlockHashConstant = Felt;
+
+static STARKNET_BLOCK_HASH0: LazyLock<BlockHashConstant> = LazyLock::new(|| {
     ascii_as_felt("STARKNET_BLOCK_HASH0").expect("ascii_as_felt failed for 'STARKNET_BLOCK_HASH0'")
 });
-pub static STARKNET_BLOCK_HASH1: LazyLock<Felt> = LazyLock::new(|| {
+pub static STARKNET_BLOCK_HASH1: LazyLock<BlockHashConstant> = LazyLock::new(|| {
     ascii_as_felt("STARKNET_BLOCK_HASH1").expect("ascii_as_felt failed for 'STARKNET_BLOCK_HASH1'")
 });
+pub static STARKNET_BLOCK_HASH2: LazyLock<BlockHashConstant> = LazyLock::new(|| {
+    ascii_as_felt("STARKNET_BLOCK_HASH2").expect("ascii_as_felt failed for 'STARKNET_BLOCK_HASH2'")
+});
 pub static STARKNET_GAS_PRICES0: LazyLock<Felt> = LazyLock::new(|| {
     ascii_as_felt("STARKNET_GAS_PRICES0").expect("ascii_as_felt failed for 'STARKNET_GAS_PRICES0'")
 });
@@ -57,13 +63,15 @@ pub static STARKNET_GAS_PRICES0: LazyLock<Felt> = LazyLock::new(|| {
 pub enum BlockHashVersion {
     V0_13_2,
     V0_13_4,
+    V0_14_3,
 }
 
 impl From<BlockHashVersion> for StarknetVersion {
     fn from(value: BlockHashVersion) -> Self {
         match value {
             BlockHashVersion::V0_13_2 => StarknetVersion::V0_13_2,
             BlockHashVersion::V0_13_4 => StarknetVersion::V0_13_4,
+            BlockHashVersion::V0_14_3 => StarknetVersion::V0_14_3,
         }
     }
 }
@@ -77,20 +85,20 @@ impl TryFrom<StarknetVersion> for BlockHashVersion {
         } else if value < Self::V0_13_4.into() {
             // Starknet versions 0.13.2 and 0.13.3 both have the same block hash mechanism.
             Ok(Self::V0_13_2)
-        } else {
+        } else if value < Self::V0_14_3.into() {
             Ok(Self::V0_13_4)
+        } else {
+            Ok(Self::V0_14_3)
         }
     }
 }
 
-// The prefix constant for the block hash calculation.
-type BlockHashConstant = Felt;
-
 impl From<BlockHashVersion> for BlockHashConstant {
     fn from(block_hash_version: BlockHashVersion) -> Self {
         match block_hash_version {
             BlockHashVersion::V0_13_2 => *STARKNET_BLOCK_HASH0,
             BlockHashVersion::V0_13_4 => *STARKNET_BLOCK_HASH1,
+            BlockHashVersion::V0_14_3 => *STARKNET_BLOCK_HASH2,
         }
     }
 }
@@ -275,6 +283,14 @@ pub fn calculate_block_hash(
                 )
                 .iter(),
             )
+            // SNIP-35: include fee_proposal_fri in the hash chain only for V0_14_3 and later.
+            .chain_if_fn(|| {
+                if block_hash_version >= BlockHashVersion::V0_14_3 {
+                    Some(partial_block_hash_components.fee_proposal_fri.0.into())
+                } else {
+                    None
+                }
+            })
             .chain(
                 &Felt::try_from(&partial_block_hash_components.starknet_version)
                     .expect("Expect ASCII version"),

crates/starknet_api/src/block_hash/block_hash_calculator_test.rs

@@ -46,11 +46,10 @@ macro_rules! test_hash_changes {
     ) => {
         {
             let partial_block_hash_components = PartialBlockHashComponents {
-                starknet_version: BlockHashVersion::V0_13_4.into(),
+                starknet_version: BlockHashVersion::V0_14_3.into(),
                 $(
                     $partial_block_hash_components_field: $partial_block_hash_components_value,
                 )*
-                ..Default::default()
             };
             let state_root = $state_root;
             let previous_block_hash = $previous_block_hash;
@@ -76,7 +75,7 @@ macro_rules! test_hash_changes {
 #[rstest]
 #[tokio::test]
 async fn test_block_hash_regression(
-    #[values(BlockHashVersion::V0_13_2, BlockHashVersion::V0_13_4)]
+    #[values(BlockHashVersion::V0_13_2, BlockHashVersion::V0_13_4, BlockHashVersion::V0_14_3)]
     block_hash_version: BlockHashVersion,
 ) {
     let state_root = GlobalRoot(Felt::from(2_u8));
@@ -119,6 +118,9 @@ async fn test_block_hash_regression(
         BlockHashVersion::V0_13_4 => {
             felt!("0x3d6174623c812f5dc03fa3faa07c42c06fd90ad425629ee5f39e149df65c3ca")
         }
+        BlockHashVersion::V0_14_3 => {
+            felt!("0x79a7eea33732ee03654abf06b7cc3e6541dcfdf8e956f32bc3e4140d90fe9ce")
+        }
     };
 
     assert_eq!(
@@ -231,6 +233,7 @@ fn extract_event_count_from_concatenated_counts_test(
 }
 
 /// Test that if one of the input to block hash changes, the hash changes.
+// TODO(AndrewL): add fee_proposal to the test.
 #[test]
 fn change_field_of_hash_input() {
     // Set non-default values for the header and the commitments fields. Test that changing any of
@@ -252,7 +255,8 @@ fn change_field_of_hash_input() {
             },
             l2_gas_price: GasPricePerToken { price_in_fri: 1_u8.into(), price_in_wei: 1_u8.into() },
             sequencer: SequencerContractAddress(ContractAddress::from(1_u128)),
-            timestamp: BlockTimestamp(1)
+            timestamp: BlockTimestamp(1),
+            fee_proposal_fri: GasPrice(1)
         },
         state_root: GlobalRoot(Felt::ONE),
         previous_block_hash: BlockHash(Felt::ONE)

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

@@ -19,7 +19,7 @@ use starknet_api::block_hash::block_hash_calculator::{
     BlockHashVersion,
     BlockHeaderCommitments,
     PartialBlockHashComponents,
-    STARKNET_BLOCK_HASH1,
+    STARKNET_BLOCK_HASH2,
 };
 use starknet_api::core::{
     EventCommitment,
@@ -90,6 +90,7 @@ fn cairo_calculate_block_hash(
         block_info_arg,
         header_commitments_arg,
         EndpointArg::from(gas_prices_hash),
+        EndpointArg::from(Felt::from(components.fee_proposal_fri.0)),
         EndpointArg::from(state_root),
         EndpointArg::from(previous_block_hash),
         EndpointArg::from(Felt::try_from(&components.starknet_version).unwrap()),
@@ -162,7 +163,7 @@ fn test_block_hash_version() {
     // 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,
+        *STARKNET_BLOCK_HASH2, latest_block_hash_version,
         "Latest block hash version constant mismatch"
     );
     assert_eq!(