chore: remove Fixed postfix from types now that the slice variations are removed

Author: kevaundray

eip7594/src/lib.rs

@@ -5,20 +5,17 @@ use verifier::VerifierContext;
 // TODO: We can remove this once we hook up the consensus-specs fixed test vectors.
 pub mod consensus_specs_fixed_test_vector;
 
-// TODO: The methods are currently not sanity checking the inputs. Example: we can pass &vec![4096] to compute_cells
-// TODO as a blob and it will panic later on in the program.
-
 pub mod constants;
 pub mod prover;
 mod serialization;
 pub mod verifier;
 
-pub type BlobRefFixed<'a> = &'a [u8; BYTES_PER_BLOB];
-pub type Bytes48RefFixed<'a> = &'a [u8; 48];
-
-pub type CellRefFixed<'a> = &'a [u8; BYTES_PER_CELL];
+pub type BlobRef<'a> = &'a [u8; BYTES_PER_BLOB];
+pub type Bytes48Ref<'a> = &'a [u8; 48];
 
 pub type Cell = Box<[u8; BYTES_PER_CELL]>;
+pub type CellRef<'a> = &'a [u8; BYTES_PER_CELL];
+
 pub type KZGProof = [u8; BYTES_PER_COMMITMENT];
 pub type KZGCommitment = [u8; BYTES_PER_COMMITMENT];
 pub type CellID = u64;

eip7594/src/prover.rs

@@ -14,7 +14,7 @@ use crate::{
     },
     serialization::{self, serialize_g1_compressed, SerializationError},
     verifier::{VerifierContext, VerifierError},
-    BlobRefFixed, Bytes48RefFixed, Cell, CellID, CellRefFixed, KZGCommitment, KZGProof,
+    BlobRef, Bytes48Ref, Cell, CellID, CellRef, KZGCommitment, KZGProof,
 };
 
 /// Errors that can occur while calling a method in the Prover API
@@ -82,7 +82,7 @@ impl ProverContext {
     }
 
     /// Computes the KZG commitment to the polynomial represented by the blob.
-    pub fn blob_to_kzg_commitment(&self, blob: BlobRefFixed) -> Result<KZGCommitment, ProverError> {
+    pub fn blob_to_kzg_commitment(&self, blob: BlobRef) -> Result<KZGCommitment, ProverError> {
         // Deserialize the blob into scalars. The blob is in lagrange form.
         let mut scalars =
             serialization::deserialize_blob_to_scalars(blob).map_err(ProverError::Serialization)?;
@@ -101,7 +101,7 @@ impl ProverContext {
     /// Computes the cells and the KZG proofs for the given blob.
     pub fn compute_cells_and_kzg_proofs(
         &self,
-        blob: BlobRefFixed,
+        blob: BlobRef,
     ) -> Result<([Cell; CELLS_PER_EXT_BLOB], [KZGProof; CELLS_PER_EXT_BLOB]), ProverError> {
         // Deserialize the blob into scalars. The blob is in lagrange form.
         let mut scalars =
@@ -137,10 +137,7 @@ impl ProverContext {
     }
 
     #[deprecated(note = "This function is deprecated, use `compute_cells_and_kzg_proofs` instead")]
-    pub fn compute_cells(
-        &self,
-        blob: BlobRefFixed,
-    ) -> Result<[Cell; CELLS_PER_EXT_BLOB], ProverError> {
+    pub fn compute_cells(&self, blob: BlobRef) -> Result<[Cell; CELLS_PER_EXT_BLOB], ProverError> {
         // Deserialize the blob into scalars. The blob is in lagrange form.
         let mut scalars =
             serialization::deserialize_blob_to_scalars(blob).map_err(ProverError::Serialization)?;
@@ -166,8 +163,8 @@ impl ProverContext {
     pub fn recover_cells_and_proofs(
         &self,
         cell_ids: Vec<CellID>,
-        cells: Vec<CellRefFixed>,
-        _proofs: Vec<Bytes48RefFixed>,
+        cells: Vec<CellRef>,
+        _proofs: Vec<Bytes48Ref>,
     ) -> Result<([Cell; CELLS_PER_EXT_BLOB], [KZGProof; CELLS_PER_EXT_BLOB]), ProverError> {
         // Use erasure decoding to recover the polynomial corresponding to the blob in monomial form
         let poly_coeff = self

eip7594/src/verifier.rs

@@ -7,7 +7,7 @@ use crate::{
     },
     prover::evaluations_to_cells,
     serialization::{deserialize_cell_to_scalars, deserialize_compressed_g1, SerializationError},
-    Bytes48RefFixed, Cell, CellID, CellRefFixed, ColumnIndex, RowIndex,
+    Bytes48Ref, Cell, CellID, CellRef, ColumnIndex, RowIndex,
 };
 use bls12_381::Scalar;
 use erasure_codes::{reed_solomon::Erasures, ReedSolomon};
@@ -93,10 +93,10 @@ impl VerifierContext {
     /// Verify that a cell is consistent with a commitment using a KZG proof.
     pub fn verify_cell_kzg_proof(
         &self,
-        commitment_bytes: Bytes48RefFixed,
+        commitment_bytes: Bytes48Ref,
         cell_id: CellID,
-        cell: CellRefFixed,
-        proof_bytes: Bytes48RefFixed,
+        cell: CellRef,
+        proof_bytes: Bytes48Ref,
     ) -> Result<(), VerifierError> {
         sanity_check_cells_and_cell_ids(&[cell_id], &[cell])?;
 
@@ -127,11 +127,11 @@ impl VerifierContext {
         // This is a deduplicated list of row commitments
         // It is not indicative of the total number of commitments in the batch.
         // This is what row_indices is used for.
-        row_commitments_bytes: Vec<Bytes48RefFixed>,
+        row_commitments_bytes: Vec<Bytes48Ref>,
         row_indices: Vec<RowIndex>,
         column_indices: Vec<ColumnIndex>,
-        cells: Vec<CellRefFixed>,
-        proofs_bytes: Vec<Bytes48RefFixed>,
+        cells: Vec<CellRef>,
+        proofs_bytes: Vec<Bytes48Ref>,
     ) -> Result<(), VerifierError> {
         // TODO: This currently uses the naive method
         //
@@ -190,7 +190,7 @@ impl VerifierContext {
     pub fn recover_all_cells(
         &self,
         cell_ids: Vec<CellID>,
-        cells: Vec<CellRefFixed>,
+        cells: Vec<CellRef>,
     ) -> Result<[Cell; CELLS_PER_EXT_BLOB], VerifierError> {
         let recovered_codeword = self.recover_extended_polynomial(cell_ids, cells)?;
         Ok(evaluations_to_cells(
@@ -201,7 +201,7 @@ impl VerifierContext {
     pub(crate) fn recover_polynomial_coeff(
         &self,
         cell_ids: Vec<CellID>,
-        cells: Vec<CellRefFixed>,
+        cells: Vec<CellRef>,
     ) -> Result<Vec<Scalar>, VerifierError> {
         // TODO: We should check that code does not assume that the CellIDs are sorted.
 
@@ -286,7 +286,7 @@ impl VerifierContext {
     pub(crate) fn recover_extended_polynomial(
         &self,
         cell_ids: Vec<CellID>,
-        cells: Vec<CellRefFixed>,
+        cells: Vec<CellRef>,
     ) -> Result<Vec<Scalar>, VerifierError> {
         let poly_coeff = self.recover_polynomial_coeff(cell_ids, cells)?;
 
@@ -308,7 +308,7 @@ fn is_cell_ids_unique(cell_ids: &[CellID]) -> bool {
 
 fn sanity_check_cells_and_cell_ids(
     cell_ids: &[CellID],
-    cells: &[CellRefFixed],
+    cells: &[CellRef],
 ) -> Result<(), VerifierError> {
     // Check that the number of cell IDs is equal to the number of cells
     if cell_ids.len() != cells.len() {