Add support for EIP-7594

Cargo.toml

@@ -26,6 +26,10 @@ serde = ["dep:serde"]
 generate-bindings = ["dep:bindgen"]
 ethereum_kzg_settings = ["dep:once_cell"]
 
+# Enable this feature when running the tests to generate the fuzzing corpus.
+# This converts the yaml reference tests into a binary form for the fuzzer.
+generate-fuzz-corpus = []
+
 # This is a standalone feature so that crates that disable default features can
 # enable blst/portable without having to add it as a dependency
 portable = ["blst/portable"]
@@ -36,6 +40,7 @@ portable = ["blst/portable"]
 no-threads = ["blst/no-threads"]
 
 [dependencies]
+arbitrary = { version = "1", features = ["derive"] }
 blst = { version = "0.3.11", default-features = false }
 hex = { version = "0.4.2", default-features = false, features = ["alloc"] }
 libc = { version = "0.2", default-features = false }

README.md

@@ -2,7 +2,7 @@
 
 A minimal implementation of the [Polynomial
 Commitments](https://github.com/ethereum/consensus-specs/blob/dev/specs/deneb/polynomial-commitments.md)
-API for EIP-4844, written in C.
+API for EIP-4844 and EIP-7594, written in C.
 
 ## Bindings
 
@@ -27,13 +27,21 @@ The C-KZG-4844 library provides implementations of the public KZG functions that
 are defined in the Polynomial Commitments specification. The aim is to align
 these functions as closely as possible with the specification.
 
+For EIP-4844:
+
 - `blob_to_kzg_commitment`
 - `compute_kzg_proof`
 - `compute_blob_kzg_proof`
 - `verify_kzg_proof`
 - `verify_blob_kzg_proof`
 - `verify_blob_kzg_proof_batch`
 
+For EIP-7594:
+
+- `compute_cells_and_kzg_proofs`
+- `recover_cells_and_kzg_proofs`
+- `verify_cell_kzg_proof_batch`
+
 This library also provides functions for loading and freeing the trusted setup,
 which are not defined in the specification. These functions are intended to be
 executed once during the initialization process. As the name suggests, the

bindings/csharp/Ckzg.Bindings/Ckzg.Bindings.cs

@@ -34,7 +34,7 @@ private static IntPtr LoadNativeLibrary(Assembly _, string path)
     }
 
     [DllImport("ckzg", EntryPoint = "load_trusted_setup_wrap")]
-    private static extern IntPtr InternalLoadTrustedSetup(string filename);
+    private static extern IntPtr InternalLoadTrustedSetup(string filename, ulong precompute);
 
     [DllImport("ckzg", EntryPoint = "free_trusted_setup_wrap", CallingConvention = CallingConvention.Cdecl)]
     private static extern void InternalFreeTrustedSetup(IntPtr ts);
@@ -58,7 +58,18 @@ private static extern unsafe KzgResult VerifyBlobKzgProof(out bool result, byte*
 
     [DllImport("ckzg", EntryPoint = "verify_blob_kzg_proof_batch", CallingConvention = CallingConvention.Cdecl)]
     private static extern unsafe KzgResult VerifyBlobKzgProofBatch(out bool result, byte* blobs, byte* commitments,
-        byte* proofs, int count, IntPtr ts);
+        byte* proofs, ulong count, IntPtr ts);
+
+    [DllImport("ckzg", EntryPoint = "compute_cells_and_kzg_proofs", CallingConvention = CallingConvention.Cdecl)]
+    private static extern unsafe KzgResult ComputeCellsAndKzgProofs(byte* cells, byte* proofs, byte* blob, IntPtr ts);
+
+    [DllImport("ckzg", EntryPoint = "recover_cells_and_kzg_proofs", CallingConvention = CallingConvention.Cdecl)]
+    private static extern unsafe KzgResult RecoverCellsAndKzgProofs(byte* recovered_cells, byte* recovered_proofs,
+        ulong* cell_indices, byte* cells, ulong num_cells, IntPtr ts);
+
+    [DllImport("ckzg", EntryPoint = "verify_cell_kzg_proof_batch", CallingConvention = CallingConvention.Cdecl)]
+    private static extern unsafe KzgResult VerifyCellKzgProofBatch(out bool result, byte* commitments,
+        ulong* cell_indices, byte* cells, byte* proofs, ulong num_cells, IntPtr ts);
 
     private enum KzgResult
     {

bindings/csharp/Ckzg.Bindings/Ckzg.Bindings.csproj

@@ -13,13 +13,13 @@
 	<PropertyGroup>
 		<Authors>Ethereum Foundation</Authors>
 		<Copyright>Ethereum Foundation</Copyright>
-		<Description>The C# bindings for the Polynomial Commitments API library for EIP-4844</Description>
+		<Description>The C# bindings for the Polynomial Commitments API library for EIP-4844 and EIP-7594</Description>
 		<EmbedUntrackedSources>true</EmbedUntrackedSources>
 		<IncludeSymbols>true</IncludeSymbols>
 		<PackageId>Ckzg.Bindings</PackageId>
 		<PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>
 		<PackageReadmeFile>README.md</PackageReadmeFile>
-		<PackageTags>c-kzg eip-4844</PackageTags>
+		<PackageTags>c-kzg eip-4844 eip-7594</PackageTags>
 		<RepositoryType>git</RepositoryType>
 		<RepositoryUrl>https://github.com/ethereum/c-kzg-4844</RepositoryUrl>
 		<SymbolPackageFormat>snupkg</SymbolPackageFormat>

bindings/csharp/Ckzg.Bindings/Ckzg.cs

@@ -2,24 +2,32 @@ namespace Ckzg;
 
 public static partial class Ckzg
 {
-    public const int BytesPerFieldElement = 32;
-    public const int FieldElementsPerBlob = 4096;
-    public const int BytesPerBlob = BytesPerFieldElement * FieldElementsPerBlob;
+
+    // Private constants.
+    private const int BytesPerFieldElement = 32;
+    private const int CellsPerExtBlob = 128;
+    private const int FieldElementsPerBlob = 4096;
+    private const int FieldElementsPerCell = 64;
+
+    // Public constants.
+    public const int BytesPerBlob = FieldElementsPerBlob * BytesPerFieldElement;
+    public const int BytesPerCell = FieldElementsPerCell * BytesPerFieldElement;
     public const int BytesPerCommitment = 48;
     public const int BytesPerProof = 48;
 
     /// <summary>
     ///     Loads trusted setup settings from file.
     /// </summary>
     /// <param name="filename">Settings file path</param>
+    /// <param name="precompute">Configurable value between 0-15</param>
     /// <exception cref="ArgumentException">Thrown when the file path is not correct</exception>
     /// <exception cref="InvalidOperationException">Thrown when unable to load the setup</exception>
     /// <returns>Trusted setup settings as a pointer</returns>
-    public static IntPtr LoadTrustedSetup(string filepath)
+    public static IntPtr LoadTrustedSetup(string filepath, int precompute)
     {
         if (!File.Exists(filepath)) throw new ArgumentException("Trusted setup file does not exist", nameof(filepath));
 
-        IntPtr ckzgSetup = InternalLoadTrustedSetup(filepath);
+        IntPtr ckzgSetup = InternalLoadTrustedSetup(filepath, (ulong)precompute);
 
         if (ckzgSetup == IntPtr.Zero) throw new InvalidOperationException("Unable to load trusted setup");
         return ckzgSetup;
@@ -30,7 +38,6 @@ public static IntPtr LoadTrustedSetup(string filepath)
     /// </summary>
     /// <param name="ckzgSetup">Trusted setup settings</param>
     /// <exception cref="ArgumentException">Thrown when settings are not correct</exception>
-
     public static void FreeTrustedSetup(IntPtr ckzgSetup)
     {
         ThrowOnUninitializedTrustedSetup(ckzgSetup);
@@ -49,8 +56,8 @@ public static void FreeTrustedSetup(IntPtr ckzgSetup)
     public static unsafe void BlobToKzgCommitment(Span<byte> commitment, ReadOnlySpan<byte> blob, IntPtr ckzgSetup)
     {
         ThrowOnUninitializedTrustedSetup(ckzgSetup);
-        ThrowOnInvalidLength(blob, nameof(blob), BytesPerBlob);
         ThrowOnInvalidLength(commitment, nameof(commitment), BytesPerCommitment);
+        ThrowOnInvalidLength(blob, nameof(blob), BytesPerBlob);
 
         fixed (byte* commitmentPtr = commitment, blobPtr = blob)
         {
@@ -191,12 +198,103 @@ public static unsafe bool VerifyBlobKzgProofBatch(ReadOnlySpan<byte> blobs, Read
         fixed (byte* blobsPtr = blobs, commitmentsPtr = commitments, proofsPtr = proofs)
         {
             KzgResult kzgResult =
-                VerifyBlobKzgProofBatch(out var result, blobsPtr, commitmentsPtr, proofsPtr, count, ckzgSetup);
+                VerifyBlobKzgProofBatch(out var result, blobsPtr, commitmentsPtr, proofsPtr, (ulong)count, ckzgSetup);
             ThrowOnError(kzgResult);
             return result;
         }
     }
 
+    /// <summary>
+    ///     Given a blob, get all of its cells and proofs.
+    /// </summary>
+    /// <param name="cells">Cells as a flattened byte array</param>
+    /// <param name="proofs">Proofs as a flattened byte array</param>
+    /// <param name="blob">Blob bytes</param>
+    /// <param name="ckzgSetup">Trusted setup settings</param>
+    /// <exception cref="ArgumentException">Thrown when length of an argument is not correct or settings are not correct</exception>
+    /// <exception cref="ApplicationException">Thrown when the library returns unexpected Error code</exception>
+    /// <exception cref="InsufficientMemoryException">Thrown when the library has no enough memory to process</exception>
+    public static unsafe void ComputeCellsAndKzgProofs(Span<byte> cells, Span<byte> proofs, ReadOnlySpan<byte> blob,
+            IntPtr ckzgSetup)
+    {
+        ThrowOnUninitializedTrustedSetup(ckzgSetup);
+        ThrowOnInvalidLength(cells, nameof(cells), BytesPerCell * CellsPerExtBlob);
+        ThrowOnInvalidLength(proofs, nameof(proofs), BytesPerProof * CellsPerExtBlob);
+        ThrowOnInvalidLength(blob, nameof(blob), BytesPerBlob);
+
+        fixed (byte* cellsPtr = cells, proofsPtr = proofs, blobPtr = blob)
+        {
+            KzgResult result = ComputeCellsAndKzgProofs(cellsPtr, proofsPtr, blobPtr, ckzgSetup);
+            ThrowOnError(result);
+        }
+    }
+
+    /// <summary>
+    ///     Given some cells for a blob, recover all cells/proofs.
+    /// </summary>
+    /// <param name="recoveredCells">Recovered cells as a flattened byte array</param>
+    /// <param name="recoveredProofs">Recovered proofs as a flattened byte array</param>
+    /// <param name="cellIndices">Cell indices as a flattened ulong array</param>
+    /// <param name="cells">Cells as a flattened byte array</param>
+    /// <param name="numCells">The number of cells provided</param>
+    /// <param name="ckzgSetup">Trusted setup settings</param>
+    /// <exception cref="ArgumentException">Thrown when length of an argument is not correct or settings are not correct</exception>
+    /// <exception cref="ApplicationException">Thrown when the library returns unexpected Error code</exception>
+    /// <exception cref="InsufficientMemoryException">Thrown when the library has no enough memory to process</exception>
+    public static unsafe void RecoverCellsAndKzgProofs(Span<byte> recoveredCells, Span<byte> recoveredProofs,
+            ReadOnlySpan<ulong> cellIndices, ReadOnlySpan<byte> cells, int numCells, IntPtr ckzgSetup)
+    {
+        ThrowOnUninitializedTrustedSetup(ckzgSetup);
+        ThrowOnInvalidLength(recoveredCells, nameof(recoveredCells), BytesPerCell * CellsPerExtBlob);
+        ThrowOnInvalidLength(recoveredProofs, nameof(recoveredProofs), BytesPerProof * CellsPerExtBlob);
+        ThrowOnInvalidLength(cellIndices, nameof(cellIndices), numCells);
+        ThrowOnInvalidLength(cells, nameof(cells), BytesPerCell * numCells);
+
+        fixed (byte* recoveredCellsPtr = recoveredCells, recoveredProofsPtr = recoveredProofs, cellsPtr = cells)
+        {
+            fixed(ulong* cellIndicesPtr = cellIndices)
+            {
+                KzgResult result = RecoverCellsAndKzgProofs(recoveredCellsPtr, recoveredProofsPtr, cellIndicesPtr,
+                    cellsPtr, (ulong)numCells, ckzgSetup);
+                ThrowOnError(result);
+            }
+        }
+    }
+
+    /// <summary>
+    ///     Given some cells, verify that their proofs are valid.
+    /// </summary>
+    /// <param name="commitmentsBytes">The commitments associated with the rows</param>
+    /// <param name="cellIndices">Cell indices as a flattened ulong array</param>
+    /// <param name="cells">Cells as a flattened byte array</param>
+    /// <param name="proofsBytes">Proofs as a flattened byte array</param>
+    /// <param name="numCells">The number of cells provided</param>
+    /// <param name="ckzgSetup">Trusted setup settings</param>
+    /// <exception cref="ArgumentException">Thrown when length of an argument is not correct or settings are not correct</exception>
+    /// <exception cref="ApplicationException">Thrown when the library returns unexpected Error code</exception>
+    /// <exception cref="InsufficientMemoryException">Thrown when the library has no enough memory to process</exception>
+    /// <returns>Verification result</returns>
+    public static unsafe bool VerifyCellKzgProofBatch(ReadOnlySpan<byte> commitments, ReadOnlySpan<ulong> cellIndices,
+            ReadOnlySpan<byte> cells, ReadOnlySpan<byte> proofs, int numCells, IntPtr ckzgSetup)
+    {
+        ThrowOnUninitializedTrustedSetup(ckzgSetup);
+        ThrowOnInvalidLength(commitments, nameof(commitments), BytesPerCommitment * numCells);
+        ThrowOnInvalidLength(cellIndices, nameof(cellIndices), numCells);
+        ThrowOnInvalidLength(cells, nameof(cells), BytesPerCell * numCells);
+        ThrowOnInvalidLength(proofs, nameof(proofs), BytesPerProof * numCells);
+
+        fixed (byte* commitmentsPtr = commitments, cellsPtr = cells, proofsPtr = proofs)
+        {
+            fixed (ulong* cellIndicesPtr = cellIndices)
+            {
+                KzgResult kzgResult = VerifyCellKzgProofBatch(out var result, commitmentsPtr,
+                    cellIndicesPtr, cellsPtr, proofsPtr, (ulong)numCells, ckzgSetup);
+                ThrowOnError(kzgResult);
+                return result;
+            }
+        }
+    }
+
     #region Argument verification helpers
     private static void ThrowOnError(KzgResult result)
     {
@@ -220,7 +318,13 @@ private static void ThrowOnUninitializedTrustedSetup(IntPtr ckzgSetup)
     private static void ThrowOnInvalidLength(ReadOnlySpan<byte> data, string fieldName, int expectedLength)
     {
         if (data.Length != expectedLength)
-            throw new ArgumentException("Invalid data size", fieldName);
+            throw new ArgumentException($"Invalid data size, got {data.Length}, expected {expectedLength}", fieldName);
+    }
+
+    private static void ThrowOnInvalidLength(ReadOnlySpan<ulong> data, string fieldName, int expectedLength)
+    {
+        if (data.Length != expectedLength)
+            throw new ArgumentException($"Invalid data size, got {data.Length}, expected {expectedLength}", fieldName);
     }
     #endregion
 }