starknet_os: rename generic SHA names to SHA256 (#14205)

Author: dorimedini-starkware

crates/blockifier/src/execution/syscalls/syscall_executor.rs

@@ -51,10 +51,8 @@ use crate::execution::syscalls::vm_syscall_utils::{
     ReplaceClassResponse,
     SendMessageToL1Request,
     SendMessageToL1Response,
-    Sha256ProcessBlockRequest,
-    Sha256ProcessBlockResponse,
-    Sha512ProcessBlockRequest,
-    Sha512ProcessBlockResponse,
+    ShaProcessBlockRequest,
+    ShaProcessBlockResponse,
     StorageReadRequest,
     StorageReadResponse,
     StorageWriteRequest,
@@ -218,11 +216,11 @@ pub trait SyscallExecutor {
     ) -> Result<MetaTxV0Response, Self::Error>;
 
     fn sha256_process_block(
-        request: Sha256ProcessBlockRequest,
+        request: ShaProcessBlockRequest,
         vm: &mut VirtualMachine,
         syscall_handler: &mut Self,
         _remaining_gas: &mut u64,
-    ) -> Result<Sha256ProcessBlockResponse, Self::Error> {
+    ) -> Result<ShaProcessBlockResponse, Self::Error> {
         const SHA256_BLOCK_SIZE: usize = 16;
 
         let data = vm
@@ -260,15 +258,15 @@ pub trait SyscallExecutor {
             state_as_words.iter().map(|&arg| MaybeRelocatable::from(Felt::from(arg))).collect();
         let response = syscall_handler.write_sha256_out_state(&data, vm)?;
 
-        Ok(Sha256ProcessBlockResponse { state_ptr: response })
+        Ok(ShaProcessBlockResponse { state_ptr: response })
     }
 
     fn sha512_process_block(
-        request: Sha512ProcessBlockRequest,
+        request: ShaProcessBlockRequest,
         vm: &mut VirtualMachine,
         syscall_handler: &mut Self,
         _remaining_gas: &mut u64,
-    ) -> Result<Sha512ProcessBlockResponse, Self::Error> {
+    ) -> Result<ShaProcessBlockResponse, Self::Error> {
         const SHA512_BLOCK_SIZE: usize = 16;
 
         let data = vm
@@ -306,7 +304,7 @@ pub trait SyscallExecutor {
             state_as_words.iter().map(|&arg| MaybeRelocatable::from(Felt::from(arg))).collect();
         let response = syscall_handler.write_sha512_out_state(&data, vm)?;
 
-        Ok(Sha512ProcessBlockResponse { state_ptr: response })
+        Ok(ShaProcessBlockResponse { state_ptr: response })
     }
 
     fn replace_class(

crates/blockifier/src/execution/syscalls/vm_syscall_utils.rs

@@ -505,64 +505,32 @@ impl SyscallResponse for KeccakResponse {
     }
 }
 
-// Sha256ProcessBlock syscall.
+// ShaProcessBlock syscall. Used for both SHA-256 and SHA-512.
 #[derive(Debug, Eq, PartialEq)]
-pub struct Sha256ProcessBlockRequest {
+pub struct ShaProcessBlockRequest {
     pub state_ptr: Relocatable,
     pub input_start: Relocatable,
 }
 
-impl SyscallRequest for Sha256ProcessBlockRequest {
+impl SyscallRequest for ShaProcessBlockRequest {
     fn read(
         vm: &VirtualMachine,
         ptr: &mut Relocatable,
-    ) -> SyscallBaseResult<Sha256ProcessBlockRequest> {
+    ) -> SyscallBaseResult<ShaProcessBlockRequest> {
         let state_start = vm.get_relocatable(*ptr)?;
         *ptr = (*ptr + 1)?;
         let input_start = vm.get_relocatable(*ptr)?;
         *ptr = (*ptr + 1)?;
-        Ok(Sha256ProcessBlockRequest { state_ptr: state_start, input_start })
+        Ok(ShaProcessBlockRequest { state_ptr: state_start, input_start })
     }
 }
 
 #[derive(Debug, Eq, PartialEq)]
-pub struct Sha256ProcessBlockResponse {
+pub struct ShaProcessBlockResponse {
     pub state_ptr: Relocatable,
 }
 
-impl SyscallResponse for Sha256ProcessBlockResponse {
-    fn write(self, vm: &mut VirtualMachine, ptr: &mut Relocatable) -> WriteResponseResult {
-        write_maybe_relocatable(vm, ptr, self.state_ptr)?;
-        Ok(())
-    }
-}
-
-// Sha512ProcessBlock syscall.
-#[derive(Debug, Eq, PartialEq)]
-pub struct Sha512ProcessBlockRequest {
-    pub state_ptr: Relocatable,
-    pub input_start: Relocatable,
-}
-
-impl SyscallRequest for Sha512ProcessBlockRequest {
-    fn read(
-        vm: &VirtualMachine,
-        ptr: &mut Relocatable,
-    ) -> SyscallBaseResult<Sha512ProcessBlockRequest> {
-        let state_start = vm.get_relocatable(*ptr)?;
-        *ptr = (*ptr + 1)?;
-        let input_start = vm.get_relocatable(*ptr)?;
-        *ptr = (*ptr + 1)?;
-        Ok(Sha512ProcessBlockRequest { state_ptr: state_start, input_start })
-    }
-}
-
-#[derive(Debug, Eq, PartialEq)]
-pub struct Sha512ProcessBlockResponse {
-    pub state_ptr: Relocatable,
-}
-
-impl SyscallResponse for Sha512ProcessBlockResponse {
+impl SyscallResponse for ShaProcessBlockResponse {
     fn write(self, vm: &mut VirtualMachine, ptr: &mut Relocatable) -> WriteResponseResult {
         write_maybe_relocatable(vm, ptr, self.state_ptr)?;
         Ok(())

crates/starknet_os/resources/hint_coverage/test_new_syscalls_flow_use_kzg_da_false_n_blocks_1.json

@@ -69,7 +69,7 @@
     "StatelessHint": "FillHolesInRc96Segment"
   },
   {
-    "StatelessHint": "Sha2Finalize"
+    "StatelessHint": "Sha256Finalize"
   },
   {
     "StatelessHint": "Sha512Finalize"

crates/starknet_os/resources/hint_coverage/test_new_syscalls_flow_use_kzg_da_true_n_blocks_5.json

@@ -69,7 +69,7 @@
     "StatelessHint": "FillHolesInRc96Segment"
   },
   {
-    "StatelessHint": "Sha2Finalize"
+    "StatelessHint": "Sha256Finalize"
   },
   {
     "StatelessHint": "Sha512Finalize"

crates/starknet_os/src/hints/enum_definition.rs

@@ -66,7 +66,7 @@ use crate::hints::hint_implementation::execute_transactions::implementation::{
     segments_add,
     segments_add_temp_initial_txs_range_check_ptr,
     set_component_hashes,
-    sha2_finalize,
+    sha256_finalize,
     sha512_finalize,
     skip_tx,
     start_tx,
@@ -273,7 +273,7 @@ use crate::hints::pythonic_hint_strings::patricia::{
 };
 use crate::hints::pythonic_hint_strings::secp::IS_ON_CURVE;
 use crate::hints::pythonic_hint_strings::segment_arena::SEGMENTS_ADD;
-use crate::hints::pythonic_hint_strings::sha256::SHA2_FINALIZE;
+use crate::hints::pythonic_hint_strings::sha256::SHA256_FINALIZE;
 use crate::hints::pythonic_hint_strings::sha512::SHA512_FINALIZE;
 use crate::hints::types::{HintContext, HintEnum};
 use crate::{
@@ -413,7 +413,7 @@ define_stateless_hint_enum!(
     (SegmentsAdd, segments_add, SEGMENTS_ADD),
     (LogRemainingTxs, log_remaining_txs),
     (FillHolesInRc96Segment, fill_holes_in_rc96_segment),
-    (Sha2Finalize, sha2_finalize, SHA2_FINALIZE),
+    (Sha256Finalize, sha256_finalize, SHA256_FINALIZE),
     (Sha512Finalize, sha512_finalize, SHA512_FINALIZE),
     (EnterScopeDeprecatedSyscallHandler, enter_scope_deprecated_syscall_handler),
     (EnterScopeSyscallHandler, enter_scope_syscall_handler),

crates/starknet_os/src/hints/hint_implementation/execute_transactions/implementation.rs

@@ -9,7 +9,7 @@ use starknet_types_core::felt::Felt;
 use crate::hint_processor::snos_hint_processor::SnosHintProcessor;
 use crate::hints::error::{OsHintError, OsHintResult};
 use crate::hints::hint_implementation::execute_transactions::utils::{
-    calculate_padding,
+    calculate_sha256_padding,
     calculate_sha512_padding,
     N_MISSING_BLOCKS_BOUND,
     SHA256_INPUT_CHUNK_SIZE_BOUND,
@@ -104,12 +104,12 @@ macro_rules! generate_sha_finalize {
 }
 
 generate_sha_finalize!(
-    sha2_finalize,
-    ShaBatchSize,
+    sha256_finalize,
+    Sha256BatchSize,
     Sha256InputChunkSize,
     SHA256_INPUT_CHUNK_SIZE_BOUND,
     Sha256PtrEnd,
-    calculate_padding
+    calculate_sha256_padding
 );
 generate_sha_finalize!(
     sha512_finalize,

crates/starknet_os/src/hints/hint_implementation/execute_transactions/utils.rs

@@ -1,4 +1,4 @@
-use cairo_vm::hint_processor::builtin_hint_processor::blake2s_hash::IV;
+use cairo_vm::hint_processor::builtin_hint_processor::blake2s_hash::IV as SHA256_IV;
 use cairo_vm::types::relocatable::MaybeRelocatable;
 use sha2::digest::generic_array::GenericArray;
 use starknet_types_core::felt::Felt;
@@ -51,5 +51,5 @@ macro_rules! generate_calculate_sha_padding {
     };
 }
 
-generate_calculate_sha_padding!(calculate_padding, u32, IV, compress256);
+generate_calculate_sha_padding!(calculate_sha256_padding, u32, SHA256_IV, compress256);
 generate_calculate_sha_padding!(calculate_sha512_padding, u64, SHA512_IV, compress512);

crates/starknet_os/src/hints/hint_implementation/execute_transactions/utils_test.rs

@@ -2,11 +2,11 @@ use cairo_vm::types::relocatable::MaybeRelocatable;
 use rstest::rstest;
 use starknet_types_core::felt::Felt;
 
-use super::{calculate_padding, calculate_sha512_padding, SHA512_IV};
+use super::{calculate_sha256_padding, calculate_sha512_padding, SHA512_IV};
 use crate::hints::hint_implementation::execute_transactions::utils::N_MISSING_BLOCKS_BOUND;
 
 #[rstest]
-fn test_calculate_padding(
+fn test_calculate_sha256_padding(
     #[values(3, 1, 0, N_MISSING_BLOCKS_BOUND - 1)] number_of_missing_blocks: u32,
 ) {
     // The expected single padding is independent of the number of missing blocks.
@@ -21,7 +21,7 @@ fn test_calculate_padding(
     let expected_padding: Vec<_> =
         (0..number_of_missing_blocks).flat_map(|_| expected_single_padding.clone()).collect();
     let sha256_input_chunk_size_felts = 16;
-    let padding = calculate_padding(sha256_input_chunk_size_felts, number_of_missing_blocks);
+    let padding = calculate_sha256_padding(sha256_input_chunk_size_felts, number_of_missing_blocks);
     assert_eq!(padding, expected_padding);
 }
 

crates/starknet_os/src/hints/pythonic_hint_strings/sha256.rs

@@ -1,6 +1,6 @@
 use indoc::indoc;
 
-pub(crate) const SHA2_FINALIZE: &str = indoc! {r#"# Add dummy pairs of input and output.
+pub(crate) const SHA256_FINALIZE: &str = indoc! {r#"# Add dummy pairs of input and output.
 from starkware.cairo.common.cairo_sha256.sha256_utils import (
     IV,
     compute_message_schedule,

crates/starknet_os/src/hints/vars.rs

@@ -360,7 +360,7 @@ define_string_enum! {
         ),
         (MerkleHeight, "starkware.starknet.core.os.state.commitment.MERKLE_HEIGHT"),
         (NUpdatesSmallPackingBound, "starkware.starknet.core.os.state.output.N_UPDATES_SMALL_PACKING_BOUND"),
-        (ShaBatchSize, "starkware.cairo.common.cairo_sha256.sha256_utils.BATCH_SIZE"),
+        (Sha256BatchSize, "starkware.cairo.common.cairo_sha256.sha256_utils.BATCH_SIZE"),
         (Sha256InputChunkSize, "starkware.cairo.common.cairo_sha256.sha256_utils.SHA256_INPUT_CHUNK_SIZE_FELTS"),
         (Sha512BatchSize, "starkware.cairo.common.cairo_sha512.sha512_utils.BATCH_SIZE"),
         (Sha512InputChunkSize, "starkware.cairo.common.cairo_sha512.sha512_utils.SHA512_INPUT_CHUNK_SIZE_FELTS"),