chore: remove "_deflattened" postfix

Author: kevaundray

bindings/c/src/compute_cells_and_kzg_proofs.rs

@@ -4,7 +4,7 @@ use crate::pointer_utils::{
 use crate::{CResult, PeerDASContext};
 use eip7594::constants::{BYTES_PER_BLOB, CELLS_PER_EXT_BLOB};
 
-pub(crate) fn _compute_cells_and_kzg_proofs_deflattened(
+pub(crate) fn _compute_cells_and_kzg_proofs(
     ctx: *const PeerDASContext,
     blob_length: u64,
     blob: *const u8,

bindings/c/src/lib.rs

@@ -4,7 +4,7 @@ mod blob_to_kzg_commitment;
 use blob_to_kzg_commitment::_blob_to_kzg_commitment;
 
 mod compute_cells_and_kzg_proofs;
-use compute_cells_and_kzg_proofs::_compute_cells_and_kzg_proofs_deflattened;
+use compute_cells_and_kzg_proofs::_compute_cells_and_kzg_proofs;
 
 mod verify_cells_and_kzg_proofs;
 use verify_cells_and_kzg_proofs::_verify_cell_kzg_proof;
@@ -172,14 +172,14 @@ pub extern "C" fn blob_to_kzg_commitment(
 /// - The caller must ensure that `out_proofs` points to a region of memory that is at least `NUM_BYTES_PROOFS` bytes.
 #[no_mangle]
 #[must_use]
-pub extern "C" fn compute_cells_and_kzg_proofs_deflattened(
+pub extern "C" fn compute_cells_and_kzg_proofs(
     ctx: *const PeerDASContext,
     blob_length: u64,
     blob: *const u8,
     out_cells: *mut *mut u8,
     out_proofs: *mut *mut u8,
 ) -> CResult {
-    match _compute_cells_and_kzg_proofs_deflattened(ctx, blob_length, blob, out_cells, out_proofs) {
+    match _compute_cells_and_kzg_proofs(ctx, blob_length, blob, out_cells, out_proofs) {
         Ok(_) => return CResult::with_ok(),
         Err(err) => return err,
     }

bindings/csharp/csharp_code/PeerDASKZG.bindings/native_methods.g.cs

@@ -35,8 +35,8 @@ public static unsafe partial class NativeMethods
         public static extern CResult blob_to_kzg_commitment(PeerDASContext* ctx, ulong blob_length, byte* blob, byte* @out);
 
         /// <summary>Safety: - The caller must ensure that the pointers are valid. If pointers are null, this method will return an error. - The caller must ensure that `blob` points to a region of memory that is at least `BYTES_PER_BLOB` bytes. - The caller must ensure that `out_cells` points to a region of memory that is at least `NUM_BYTES_CELLS` bytes. - The caller must ensure that `out_proofs` points to a region of memory that is at least `NUM_BYTES_PROOFS` bytes.</summary>
-        [DllImport(__DllName, EntryPoint = "compute_cells_and_kzg_proofs_deflattened", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
-        public static extern CResult compute_cells_and_kzg_proofs_deflattened(PeerDASContext* ctx, ulong blob_length, byte* blob, byte** out_cells, byte** out_proofs);
+        [DllImport(__DllName, EntryPoint = "compute_cells_and_kzg_proofs", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern CResult compute_cells_and_kzg_proofs(PeerDASContext* ctx, ulong blob_length, byte* blob, byte** out_cells, byte** out_proofs);
 
         /// <summary>Safety: - The caller must ensure that the pointers are valid. If pointers are null, this method will return an error. - The caller must ensure that `cell` points to a region of memory that is at least `BYTES_PER_CELL` bytes. - The caller must ensure that `commitment` points to a region of memory that is at least `BYTES_PER_COMMITMENT` bytes. - The caller must ensure that `proof` points to a region of memory that is at least `BYTES_PER_COMMITMENT` bytes. - The caller must ensure that `verified` points to a region of memory that is at least 1 byte.</summary>
         [DllImport(__DllName, EntryPoint = "verify_cell_kzg_proof", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]

bindings/csharp/csharp_code/PeerDASKZG.bindings/peerdaskzg.cs

@@ -96,7 +96,7 @@ public unsafe (byte[][], byte[][]) ComputeCellsAndKZGProofs(byte[] blob)
                 }
             }
 
-            CResult result = compute_cells_and_kzg_proofs_deflattened(_context, Convert.ToUInt64(blob.Length), blobPtr, outCellsPtrPtr, outProofsPtrPtr);
+            CResult result = compute_cells_and_kzg_proofs(_context, Convert.ToUInt64(blob.Length), blobPtr, outCellsPtrPtr, outProofsPtrPtr);
             ThrowOnError(result);
         }
         return (outCells, outProofs);

bindings/java/rust_code/src/lib.rs

@@ -76,7 +76,7 @@ pub unsafe extern "system" fn Java_ethereum_cryptography_LibPeerDASKZG_computeCe
     let out_cells_ptr_ptr = vec_vec_u8_to_ptr_ptr_u8_mut(&mut out_cells);
     let out_proofs_ptr_ptr = vec_vec_u8_to_ptr_ptr_u8_mut(&mut out_proofs);
 
-    let result = c_peerdas_kzg::compute_cells_and_kzg_proofs_deflattened(
+    let result = c_peerdas_kzg::compute_cells_and_kzg_proofs(
         ctx,
         blob.len() as u64,
         blob.as_ptr(),

bindings/nim/nim_code/src/header.nim

@@ -43,11 +43,11 @@ proc blob_to_kzg_commitment*(ctx: ptr PeerDASContext,
 # - The caller must ensure that `blob` points to a region of memory that is at least `BYTES_PER_BLOB` bytes.
 # - The caller must ensure that `out_cells` points to a region of memory that is at least `NUM_BYTES_CELLS` bytes.
 # - The caller must ensure that `out_proofs` points to a region of memory that is at least `NUM_BYTES_PROOFS` bytes.
-proc compute_cells_and_kzg_proofs_deflattened*(ctx: ptr PeerDASContext,
-                                               blob_length: uint64,
-                                               blob: pointer,
-                                               out_cells: ptr pointer,
-                                               out_proofs: ptr pointer): CResult {.importc: "compute_cells_and_kzg_proofs_deflattened".}
+proc compute_cells_and_kzg_proofs*(ctx: ptr PeerDASContext,
+                                   blob_length: uint64,
+                                   blob: pointer,
+                                   out_cells: ptr pointer,
+                                   out_proofs: ptr pointer): CResult {.importc: "compute_cells_and_kzg_proofs".}
 
 ## Safety:
 # - The caller must ensure that the pointers are valid. If pointers are null, this method will return an error.