Rename ShaChipConfig to Sha2ChipConfig for consistency with Sha2Config

Author: Avaneesh-axiom

extensions/sha2/circuit/src/sha2_chip/air.rs

@@ -23,12 +23,12 @@ use openvm_stark_backend::{
     rap::{BaseAirWithPublicValues, PartitionedBaseAir},
 };
 
-use super::{Sha2VmDigestColsRef, Sha2VmRoundColsRef, ShaChipConfig};
+use super::{Sha2VmDigestColsRef, Sha2VmRoundColsRef, Sha2ChipConfig};
 
 /// Sha2VmAir does all constraints related to message padding and
 /// the Sha2Air subair constrains the actual hash
 #[derive(Clone, Debug)]
-pub struct Sha2VmAir<C: ShaChipConfig> {
+pub struct Sha2VmAir<C: Sha2ChipConfig> {
     pub execution_bridge: ExecutionBridge,
     pub memory_bridge: MemoryBridge,
     /// Bus to send byte checks to
@@ -40,7 +40,7 @@ pub struct Sha2VmAir<C: ShaChipConfig> {
     pub(super) padding_encoder: Encoder,
 }
 
-impl<C: ShaChipConfig> Sha2VmAir<C> {
+impl<C: Sha2ChipConfig> Sha2VmAir<C> {
     pub fn new(
         SystemPort {
             execution_bus,
@@ -63,15 +63,15 @@ impl<C: ShaChipConfig> Sha2VmAir<C> {
     }
 }
 
-impl<F: Field, C: ShaChipConfig> BaseAirWithPublicValues<F> for Sha2VmAir<C> {}
-impl<F: Field, C: ShaChipConfig> PartitionedBaseAir<F> for Sha2VmAir<C> {}
-impl<F: Field, C: ShaChipConfig> BaseAir<F> for Sha2VmAir<C> {
+impl<F: Field, C: Sha2ChipConfig> BaseAirWithPublicValues<F> for Sha2VmAir<C> {}
+impl<F: Field, C: Sha2ChipConfig> PartitionedBaseAir<F> for Sha2VmAir<C> {}
+impl<F: Field, C: Sha2ChipConfig> BaseAir<F> for Sha2VmAir<C> {
     fn width(&self) -> usize {
         C::VM_WIDTH
     }
 }
 
-impl<AB: InteractionBuilder, C: ShaChipConfig> Air<AB> for Sha2VmAir<C> {
+impl<AB: InteractionBuilder, C: Sha2ChipConfig> Air<AB> for Sha2VmAir<C> {
     fn eval(&self, builder: &mut AB) {
         self.eval_padding(builder);
         self.eval_transitions(builder);
@@ -156,7 +156,7 @@ impl PaddingFlags {
 }
 
 use PaddingFlags::*;
-impl<C: ShaChipConfig> Sha2VmAir<C> {
+impl<C: Sha2ChipConfig> Sha2VmAir<C> {
     /// Implement all necessary constraints for the padding
     fn eval_padding<AB: InteractionBuilder>(&self, builder: &mut AB) {
         let main = builder.main();

extensions/sha2/circuit/src/sha2_chip/columns.rs

@@ -12,13 +12,13 @@ use openvm_sha2_air::{
 };
 
 use super::SHA_REGISTER_READS;
-use crate::ShaChipConfig;
+use crate::Sha2ChipConfig;
 
 /// the first C::ROUND_ROWS rows of every SHA block will be of type ShaVmRoundCols and the last row
 /// will be of type ShaVmDigestCols
 #[repr(C)]
 #[derive(Clone, Copy, Debug, ColsRef)]
-#[config(ShaChipConfig)]
+#[config(Sha2ChipConfig)]
 pub struct Sha2VmRoundCols<
     T,
     const WORD_BITS: usize,
@@ -44,7 +44,7 @@ pub struct Sha2VmRoundCols<
 
 #[repr(C)]
 #[derive(Clone, Copy, Debug, ColsRef)]
-#[config(ShaChipConfig)]
+#[config(Sha2ChipConfig)]
 pub struct Sha2VmDigestCols<
     T,
     const WORD_BITS: usize,
@@ -90,7 +90,7 @@ pub struct Sha2VmDigestCols<
 /// These are the columns that are used on both round and digest rows
 #[repr(C)]
 #[derive(Clone, Copy, Debug, ColsRef)]
-#[config(ShaChipConfig)]
+#[config(Sha2ChipConfig)]
 pub struct Sha2VmControlCols<T> {
     /// Note: We will use the buffer in `inner.message_schedule` as the message data
     /// This is the length of the entire message in bytes

extensions/sha2/circuit/src/sha2_chip/config.rs

@@ -4,7 +4,7 @@ use openvm_sha2_transpiler::Rv32Sha2Opcode;
 
 use super::{Sha2VmControlColsRef, Sha2VmDigestColsRef, Sha2VmRoundColsRef};
 
-pub trait ShaChipConfig: Sha2Config {
+pub trait Sha2ChipConfig: Sha2Config {
     // Name of the opcode
     const OPCODE_NAME: &'static str;
     /// Width of the ShaVmControlCols
@@ -51,7 +51,7 @@ pub trait ShaChipConfig: Sha2Config {
 /// Register reads to get dst, src, len
 pub const SHA_REGISTER_READS: usize = 3;
 
-impl ShaChipConfig for Sha256Config {
+impl Sha2ChipConfig for Sha256Config {
     const OPCODE_NAME: &'static str = "SHA256";
     const MESSAGE_LENGTH_BITS: usize = 64;
     const WRITE_SIZE: usize = SHA_WRITE_SIZE;
@@ -60,7 +60,7 @@ impl ShaChipConfig for Sha256Config {
     const DIGEST_SIZE: usize = Self::HASH_SIZE;
 }
 
-impl ShaChipConfig for Sha512Config {
+impl Sha2ChipConfig for Sha512Config {
     const OPCODE_NAME: &'static str = "SHA512";
     const MESSAGE_LENGTH_BITS: usize = 128;
     const WRITE_SIZE: usize = SHA_WRITE_SIZE;
@@ -69,7 +69,7 @@ impl ShaChipConfig for Sha512Config {
     const DIGEST_SIZE: usize = Self::HASH_SIZE;
 }
 
-impl ShaChipConfig for Sha384Config {
+impl Sha2ChipConfig for Sha384Config {
     const OPCODE_NAME: &'static str = "SHA384";
     const MESSAGE_LENGTH_BITS: usize = 128;
     const WRITE_SIZE: usize = SHA_WRITE_SIZE;

extensions/sha2/circuit/src/sha2_chip/mod.rs

@@ -43,15 +43,15 @@ mod tests;
 
 pub type Sha2VmChip<F, C> = NewVmChipWrapper<F, Sha2VmAir<C>, Sha2VmStep<C>, MatrixRecordArena<F>>;
 
-pub struct Sha2VmStep<C: ShaChipConfig> {
+pub struct Sha2VmStep<C: Sha2ChipConfig> {
     pub inner: Sha2StepHelper<C>,
     pub padding_encoder: Encoder,
     pub bitwise_lookup_chip: SharedBitwiseOperationLookupChip<RV32_CELL_BITS>,
     pub offset: usize,
     pub pointer_max_bits: usize,
 }
 
-impl<C: ShaChipConfig> Sha2VmStep<C> {
+impl<C: Sha2ChipConfig> Sha2VmStep<C> {
     pub fn new(
         bitwise_lookup_chip: SharedBitwiseOperationLookupChip<RV32_CELL_BITS>,
         offset: usize,
@@ -67,7 +67,7 @@ impl<C: ShaChipConfig> Sha2VmStep<C> {
     }
 }
 
-impl<F: PrimeField32, C: ShaChipConfig> StepExecutorE1<F> for Sha2VmStep<C> {
+impl<F: PrimeField32, C: Sha2ChipConfig> StepExecutorE1<F> for Sha2VmStep<C> {
     fn execute_e1<Ctx>(
         &self,
         state: &mut VmStateMut<F, GuestMemory, Ctx>,
@@ -266,7 +266,7 @@ impl<F: PrimeField32, C: ShaChipConfig> StepExecutorE1<F> for Sha2VmStep<C> {
     }
 }
 
-pub fn sha2_solve<C: ShaChipConfig>(input_message: &[u8]) -> Vec<u8> {
+pub fn sha2_solve<C: Sha2ChipConfig>(input_message: &[u8]) -> Vec<u8> {
     match C::VARIANT {
         Sha2Variant::Sha256 => {
             let mut hasher = Sha256::new();

extensions/sha2/circuit/src/sha2_chip/tests.rs

@@ -17,7 +17,7 @@ use openvm_stark_backend::{interaction::BusIndex, p3_field::FieldAlgebra};
 use openvm_stark_sdk::{config::setup_tracing, p3_baby_bear::BabyBear, utils::create_seeded_rng};
 use rand::{rngs::StdRng, Rng};
 
-use super::{Sha2VmAir, Sha2VmChip, Sha2VmStep, ShaChipConfig};
+use super::{Sha2ChipConfig, Sha2VmAir, Sha2VmChip, Sha2VmStep};
 use crate::{
     sha2_chip::trace::Sha2VmRecordLayout, sha2_solve, Sha2VmDigestColsRef, Sha2VmRoundColsRef,
 };
@@ -27,7 +27,7 @@ const SELF_BUS_IDX: BusIndex = 28;
 const MAX_INS_CAPACITY: usize = 8192;
 type Sha2VmChipDense<C> = NewVmChipWrapper<F, Sha2VmAir<C>, Sha2VmStep<C>, DenseRecordArena>;
 
-fn create_test_chips<C: ShaChipConfig>(
+fn create_test_chips<C: Sha2ChipConfig>(
     tester: &mut VmChipTestBuilder<F>,
 ) -> (
     Sha2VmChip<F, C>,
@@ -54,7 +54,7 @@ fn create_test_chips<C: ShaChipConfig>(
     (chip, bitwise_chip)
 }
 
-fn set_and_execute<E: InstructionExecutor<F>, C: ShaChipConfig>(
+fn set_and_execute<E: InstructionExecutor<F>, C: Sha2ChipConfig>(
     tester: &mut VmChipTestBuilder<F>,
     chip: &mut E,
     rng: &mut StdRng,
@@ -131,7 +131,7 @@ fn set_and_execute<E: InstructionExecutor<F>, C: ShaChipConfig>(
 /// Randomly generate computations and execute, ensuring that the generated trace
 /// passes all constraints.
 ///////////////////////////////////////////////////////////////////////////////////////
-fn rand_sha_test<C: ShaChipConfig + 'static>() {
+fn rand_sha_test<C: Sha2ChipConfig + 'static>() {
     setup_tracing();
     let mut rng = create_seeded_rng();
     let mut tester = VmChipTestBuilder::default();
@@ -166,7 +166,7 @@ fn rand_sha384_test() {
 ///
 /// Ensure that solve functions produce the correct results.
 ///////////////////////////////////////////////////////////////////////////////////////
-fn execute_roundtrip_sanity_test<C: ShaChipConfig>() {
+fn execute_roundtrip_sanity_test<C: Sha2ChipConfig>() {
     let mut rng = create_seeded_rng();
     let mut tester = VmChipTestBuilder::default();
     let (mut chip, _) = create_test_chips::<C>(&mut tester);
@@ -246,7 +246,7 @@ fn sha384_solve_sanity_check() {
 /// to a [MatrixRecordArena]. After transferring we generate the trace and make sure that
 /// all the constraints pass.
 ///////////////////////////////////////////////////////////////////////////////////////
-fn create_test_chip_dense<C: ShaChipConfig>(
+fn create_test_chip_dense<C: Sha2ChipConfig>(
     tester: &mut VmChipTestBuilder<F>,
 ) -> Sha2VmChipDense<C> {
     let bitwise_bus = BitwiseOperationLookupBus::new(BITWISE_OP_LOOKUP_BUS);
@@ -271,7 +271,7 @@ fn create_test_chip_dense<C: ShaChipConfig>(
     chip
 }
 
-fn dense_record_arena_test<C: ShaChipConfig + 'static>() {
+fn dense_record_arena_test<C: Sha2ChipConfig + 'static>() {
     let mut rng = create_seeded_rng();
     let mut tester = VmChipTestBuilder::default();
     let (mut sparse_chip, bitwise_chip) = create_test_chips::<C>(&mut tester);

extensions/sha2/circuit/src/sha2_chip/trace.rs

@@ -34,20 +34,20 @@ use openvm_stark_backend::{
 };
 
 use super::{
-    Sha2Variant, Sha2VmDigestColsRefMut, Sha2VmRoundColsRefMut, Sha2VmStep, ShaChipConfig,
+    Sha2Variant, Sha2VmDigestColsRefMut, Sha2VmRoundColsRefMut, Sha2VmStep, Sha2ChipConfig,
 };
 use crate::{
     get_sha2_num_blocks, sha2_chip::PaddingFlags, sha2_solve, Sha2VmControlColsRefMut,
     MAX_SHA_NUM_WRITES, SHA_MAX_MESSAGE_LEN, SHA_REGISTER_READS, SHA_WRITE_SIZE,
 };
 
 #[derive(Clone, Copy)]
-pub struct Sha2VmMetadata<C: ShaChipConfig> {
+pub struct Sha2VmMetadata<C: Sha2ChipConfig> {
     pub num_blocks: u32,
     _phantom: PhantomData<C>,
 }
 
-impl<C: ShaChipConfig> MultiRowMetadata for Sha2VmMetadata<C> {
+impl<C: Sha2ChipConfig> MultiRowMetadata for Sha2VmMetadata<C> {
     #[inline(always)]
     fn get_num_rows(&self) -> usize {
         self.num_blocks as usize * C::ROWS_PER_BLOCK
@@ -87,7 +87,7 @@ pub struct Sha2VmRecordMut<'a> {
 /// `C::NUM_READ_ROWS * num_blocks`. Uses `align_to_mut()` to make sure the slice is properly
 /// aligned to `MemoryReadAuxRecord`. Has debug assertions that check the size and alignment of the
 /// slices.
-impl<'a, C: ShaChipConfig> CustomBorrow<'a, Sha2VmRecordMut<'a>, Sha2VmRecordLayout<C>> for [u8] {
+impl<'a, C: Sha2ChipConfig> CustomBorrow<'a, Sha2VmRecordMut<'a>, Sha2VmRecordLayout<C>> for [u8] {
     fn custom_borrow(&'a mut self, layout: Sha2VmRecordLayout<C>) -> Sha2VmRecordMut<'a> {
         let (header_buf, rest) =
             unsafe { self.split_at_mut_unchecked(size_of::<Sha2VmRecordHeader>()) };
@@ -123,7 +123,7 @@ impl<'a, C: ShaChipConfig> CustomBorrow<'a, Sha2VmRecordMut<'a>, Sha2VmRecordLay
     }
 }
 
-impl<C: ShaChipConfig> SizedRecord<Sha2VmRecordLayout<C>> for Sha2VmRecordMut<'_> {
+impl<C: Sha2ChipConfig> SizedRecord<Sha2VmRecordLayout<C>> for Sha2VmRecordMut<'_> {
     fn size(layout: &Sha2VmRecordLayout<C>) -> usize {
         let mut total_len = size_of::<Sha2VmRecordHeader>();
         total_len += layout.metadata.num_blocks as usize * C::BLOCK_CELLS;
@@ -140,7 +140,7 @@ impl<C: ShaChipConfig> SizedRecord<Sha2VmRecordLayout<C>> for Sha2VmRecordMut<'_
     }
 }
 
-impl<F: PrimeField32, CTX, C: ShaChipConfig> TraceStep<F, CTX> for Sha2VmStep<C> {
+impl<F: PrimeField32, CTX, C: Sha2ChipConfig> TraceStep<F, CTX> for Sha2VmStep<C> {
     type RecordLayout = Sha2VmRecordLayout<C>;
     type RecordMut<'a> = Sha2VmRecordMut<'a>;
 
@@ -310,7 +310,7 @@ impl<F: PrimeField32, CTX, C: ShaChipConfig> TraceStep<F, CTX> for Sha2VmStep<C>
     }
 }
 
-impl<F: PrimeField32, CTX, C: ShaChipConfig> TraceFiller<F, CTX> for Sha2VmStep<C> {
+impl<F: PrimeField32, CTX, C: Sha2ChipConfig> TraceFiller<F, CTX> for Sha2VmStep<C> {
     fn fill_trace(
         &self,
         mem_helper: &MemoryAuxColsFactory<F>,
@@ -450,7 +450,7 @@ impl<F: PrimeField32, CTX, C: ShaChipConfig> TraceFiller<F, CTX> for Sha2VmStep<
     }
 }
 
-impl<C: ShaChipConfig> Sha2VmStep<C> {
+impl<C: Sha2ChipConfig> Sha2VmStep<C> {
     #[allow(clippy::too_many_arguments)]
     fn fill_block_trace<F: PrimeField32>(
         &self,

extensions/sha2/circuit/src/sha2_chip/utils.rs

@@ -1,7 +1,7 @@
-use crate::ShaChipConfig;
+use crate::Sha2ChipConfig;
 
 /// Returns the number of blocks required to hash a message of length `len`
-pub fn get_sha2_num_blocks<C: ShaChipConfig>(len: u32) -> u32 {
+pub fn get_sha2_num_blocks<C: Sha2ChipConfig>(len: u32) -> u32 {
     // need to pad with one 1 bit, 64 bits for the message length and then pad until the length
     // is divisible by [C::BLOCK_BITS]
     ((len << 3) as usize + 1 + C::MESSAGE_LENGTH_BITS).div_ceil(C::BLOCK_BITS) as u32