ckzg 1.0.1__tar.gz

ckzg-1.0.1/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

ckzg-1.0.1/MANIFEST.in

@@ -0,0 +1,10 @@
+# This is a manifest for the Python bindings
+include bindings/python/ckzg.c
+include bindings/python/README.md
+recursive-include blst *
+recursive-include lib *
+recursive-include inc *
+recursive-include src *
+include setup.py
+include LICENSE
+include README.md

ckzg-1.0.1/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.1
+Name: ckzg
+Version: 1.0.1
+Summary: Python bindings for C-KZG-4844
+Home-page: https://github.com/ethereum/c-kzg-4844
+Author: Ethereum Foundation
+Author-email: security@ethereum.org
+License: Apache-2.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Python bindings
+
+This directory contains Python bindings for the C-KZG-4844 library.
+
+## Prerequisites
+
+These bindings require `python3` and `PyYAML`.
+```
+sudo apt install python3 python3-pip
+python3 -m pip install PyYAML
+```
+
+## Build & test
+
+Everything is consolidated into one command:
+```
+make
+```
+
+You should expect to see these messages at the bottom:
+```
+python3 tests.py
+tests passed
+```

ckzg-1.0.1/README.md

@@ -0,0 +1,98 @@
+# C-KZG-4844
+
+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.
+
+## Bindings
+
+While the core implementation is in C, bindings are available for various
+high-level languages, providing convenient wrappers around C functions. These
+bindings are intended to be used by Ethereum clients, to avoid re-implementation
+of crucial cryptographic functions.
+
+| Language | Link                                 |
+|----------|--------------------------------------|
+| C#       | [README](bindings/csharp/README.md)  |
+| Go       | [README](bindings/go/README.md)      |
+| Java     | [README](bindings/java/README.md)    |
+| Nim      | [README](bindings/nim/README.md)     |
+| Node.js  | [README](bindings/node.js/README.md) |
+| Python   | [README](bindings/python/README.md)  |
+| Rust     | [README](bindings/rust/README.md)    |
+
+## Interface functions
+
+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.
+
+- `blob_to_kzg_commitment`
+- `compute_kzg_proof`
+- `compute_blob_kzg_proof`
+- `verify_kzg_proof`
+- `verify_blob_kzg_proof`
+- `verify_blob_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
+[trusted setup
+file](https://github.com/ethereum/c-kzg-4844/blob/main/src/trusted_setup.txt) is
+considered to be trustworthy.
+
+- `load_trusted_setup`
+- `load_trusted_setup_file`
+- `free_trusted_setup`
+
+## Remarks
+
+### Tests
+
+All the bindings are tested against the [KZG reference
+tests](https://github.com/ethereum/consensus-spec-tests/tree/master/tests/general/deneb/kzg),
+which are defined in the consensus-spec-tests. Additionally, a suite of unit
+tests for internal C functions is located
+[here](https://github.com/ethereum/c-kzg-4844/blob/main/src/test_c_kzg_4844.c).
+
+### Parallelization
+
+The interface functions in C-KZG-4844 are single-threaded for simplicity, as
+implementing multi-threading across multiple platforms can be complex. While
+performance is important, these functions are already quite fast and efficient.
+For instance, `verify_blob_kzg_proof` is expected to finish in under 3ms on most
+systems.
+
+### Batched verification
+
+When processing multiple blobs, `verify_blob_kzg_proof_batch` is more efficient
+than calling `verify_blob_kzg_proof` individually. In CI tests, verifying 64
+blobs in batch is 53% faster per blob than verifying them individually. For a
+single blob, `verify_blob_kzg_proof_batch` calls `verify_blob_kzg_proof`, and
+the overhead is negligible.
+
+### Benchmarks
+
+C-KZG-4844 does not include C benchmarks; however, some bindings (Go, Java, and
+Rust) have their own benchmarks. Including benchmarks in the bindings offers a
+more realistic performance estimate, as C-KZG-4844 is not expected to be used
+outside the bindings.
+
+### Security audit
+
+The source code of C-KZG-4844 was audited by [Sigma
+Prime](https://sigmaprime.io/) in June 2023. You can find the [audit
+report](https://github.com/ethereum/c-kzg-4844/blob/main/doc/audit/Sigma_Prime_Ethereum_Foundation_KZG_Implementations_Security_Assessment.pdf)
+in the `doc/audit/` directory.
+
+### Why C?
+
+The primary reason for choosing C is that
+[blst](https://github.com/supranational/blst), the BLS12-381 signature library
+we wanted to use, is mostly written in C. Rust was a viable alternative, but it
+has some disadvantages. The C toolchain is ubiquitous, and it would be somewhat
+awkward for all the bindings to depend on another toolchain, such as Rust.
+Compared to Rust, C offers a lighter memory and binary footprint. Furthermore, C
+serves as the de facto language for
+[FFI](https://en.wikipedia.org/wiki/Foreign_function_interface), so we could not
+have completely avoided using C anyway.

ckzg-1.0.1/bindings/python/README.md

@@ -0,0 +1,24 @@
+# Python bindings
+
+This directory contains Python bindings for the C-KZG-4844 library.
+
+## Prerequisites
+
+These bindings require `python3` and `PyYAML`.
+```
+sudo apt install python3 python3-pip
+python3 -m pip install PyYAML
+```
+
+## Build & test
+
+Everything is consolidated into one command:
+```
+make
+```
+
+You should expect to see these messages at the bottom:
+```
+python3 tests.py
+tests passed
+```

ckzg-1.0.1/bindings/python/ckzg.c

@@ -0,0 +1,258 @@
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+#include "c_kzg_4844.h"
+
+static void free_KZGSettings(PyObject *c) {
+  KZGSettings *s = PyCapsule_GetPointer(c, "KZGSettings");
+  free_trusted_setup(s);
+  free(s);
+}
+
+static PyObject* load_trusted_setup_wrap(PyObject *self, PyObject *args) {
+  PyObject *f;
+  FILE *fp;
+
+  if (!PyArg_ParseTuple(args, "U", &f))
+    return PyErr_Format(PyExc_ValueError, "expected a string");
+
+  KZGSettings *s = (KZGSettings*)malloc(sizeof(KZGSettings));
+  if (s == NULL) return PyErr_NoMemory();
+
+  fp = fopen(PyUnicode_AsUTF8(f), "r");
+  if (fp == NULL) {
+    free(s);
+    return PyErr_Format(PyExc_RuntimeError, "error reading trusted setup");
+  }
+
+  C_KZG_RET ret = load_trusted_setup_file(s, fp);
+  fclose(fp);
+
+  if (ret != C_KZG_OK) {
+    free(s);
+    return PyErr_Format(PyExc_RuntimeError, "error loading trusted setup");
+  }
+
+  return PyCapsule_New(s, "KZGSettings", free_KZGSettings);
+}
+
+static PyObject* blob_to_kzg_commitment_wrap(PyObject *self, PyObject *args) {
+  PyObject *b;
+  PyObject *s;
+
+  if (!PyArg_UnpackTuple(args, "blob_to_kzg_commitment_wrap", 2, 2, &b, &s) ||
+      !PyBytes_Check(b) ||
+      !PyCapsule_IsValid(s, "KZGSettings"))
+    return PyErr_Format(PyExc_ValueError, "expected bytes and trusted setup");
+
+  if (PyBytes_Size(b) != BYTES_PER_BLOB)
+    return PyErr_Format(PyExc_ValueError, "expected blobs to be BYTES_PER_BLOB bytes");
+
+  PyObject *out = PyBytes_FromStringAndSize(NULL, BYTES_PER_COMMITMENT);
+  if (out == NULL) return PyErr_NoMemory();
+
+  Blob *blob = (Blob *)PyBytes_AsString(b);
+  KZGCommitment *k = (KZGCommitment *)PyBytes_AsString(out);
+  if (blob_to_kzg_commitment(k, blob, PyCapsule_GetPointer(s, "KZGSettings")) != C_KZG_OK) {
+    Py_DECREF(out);
+    return PyErr_Format(PyExc_RuntimeError, "blob_to_kzg_commitment failed");
+  }
+
+  return out;
+}
+
+static PyObject* compute_kzg_proof_wrap(PyObject *self, PyObject *args) {
+  PyObject *b, *z, *s;
+
+  if (!PyArg_UnpackTuple(args, "compute_kzg_proof_wrap", 3, 3, &b, &z, &s) ||
+      !PyBytes_Check(b) ||
+      !PyBytes_Check(z) ||
+      !PyCapsule_IsValid(s, "KZGSettings"))
+    return PyErr_Format(PyExc_ValueError, "expected bytes, bytes, trusted setup");
+
+  if (PyBytes_Size(b) != BYTES_PER_BLOB)
+    return PyErr_Format(PyExc_ValueError, "expected blobs to be BYTES_PER_BLOB bytes");
+  if (PyBytes_Size(z) != BYTES_PER_FIELD_ELEMENT)
+    return PyErr_Format(PyExc_ValueError, "expected blobs to be BYTES_PER_FIELD_ELEMENT bytes");
+
+  PyObject *py_y = PyBytes_FromStringAndSize(NULL, BYTES_PER_FIELD_ELEMENT);
+  if (py_y == NULL) return PyErr_NoMemory();
+  PyObject *py_proof = PyBytes_FromStringAndSize(NULL, BYTES_PER_PROOF);
+  if (py_proof == NULL) return PyErr_NoMemory();
+
+  PyObject *out = PyTuple_Pack(2, py_proof, py_y);
+  if (out == NULL) return PyErr_NoMemory();
+
+  Blob *blob = (Blob *)PyBytes_AsString(b);
+  Bytes32 *z_bytes = (Bytes32 *)PyBytes_AsString(z);
+  KZGProof *proof = (KZGProof *)PyBytes_AsString(py_proof);
+  Bytes32 *y_bytes = (Bytes32 *)PyBytes_AsString(py_y);
+  if (compute_kzg_proof(proof, y_bytes, blob, z_bytes, PyCapsule_GetPointer(s, "KZGSettings")) != C_KZG_OK) {
+    Py_DECREF(out);
+    return PyErr_Format(PyExc_RuntimeError, "compute_kzg_proof failed");
+  }
+
+  return out;
+}
+
+static PyObject* compute_blob_kzg_proof_wrap(PyObject *self, PyObject *args) {
+  PyObject *b, *c, *s;
+
+  if (!PyArg_UnpackTuple(args, "compute_blob_kzg_proof_wrap", 3, 3, &b, &c, &s) ||
+      !PyBytes_Check(b) ||
+      !PyBytes_Check(c) ||
+      !PyCapsule_IsValid(s, "KZGSettings"))
+    return PyErr_Format(PyExc_ValueError, "expected bytes, bytes, trusted setup");
+
+  if (PyBytes_Size(b) != BYTES_PER_BLOB)
+    return PyErr_Format(PyExc_ValueError, "expected blobs to be BYTES_PER_BLOB bytes");
+  if (PyBytes_Size(c) != BYTES_PER_COMMITMENT)
+    return PyErr_Format(PyExc_ValueError, "expected commitment to be BYTES_PER_COMMITMENT bytes");
+
+  PyObject *out = PyBytes_FromStringAndSize(NULL, BYTES_PER_PROOF);
+  if (out == NULL) return PyErr_NoMemory();
+
+  Blob *blob = (Blob *)PyBytes_AsString(b);
+  Bytes48 *commitment_bytes = (Bytes48 *)PyBytes_AsString(c);
+  KZGProof *proof = (KZGProof *)PyBytes_AsString(out);
+  if (compute_blob_kzg_proof(proof, blob, commitment_bytes, PyCapsule_GetPointer(s, "KZGSettings")) != C_KZG_OK) {
+    Py_DECREF(out);
+    return PyErr_Format(PyExc_RuntimeError, "compute_blob_kzg_proof failed");
+  }
+
+  return out;
+}
+
+static PyObject* verify_kzg_proof_wrap(PyObject *self, PyObject *args) {
+  PyObject *c, *z, *y, *p, *s;
+
+  if (!PyArg_UnpackTuple(args, "verify_kzg_proof", 5, 5, &c, &z, &y, &p, &s) ||
+      !PyBytes_Check(c) ||
+      !PyBytes_Check(z) ||
+      !PyBytes_Check(y) ||
+      !PyBytes_Check(p) ||
+      !PyCapsule_IsValid(s, "KZGSettings"))
+    return PyErr_Format(PyExc_ValueError,
+        "expected bytes, bytes, bytes, bytes, trusted setup");
+
+  if (PyBytes_Size(c) != BYTES_PER_COMMITMENT)
+    return PyErr_Format(PyExc_ValueError, "expected commitment to be BYTES_PER_COMMITMENT bytes");
+  if (PyBytes_Size(z) != BYTES_PER_FIELD_ELEMENT)
+    return PyErr_Format(PyExc_ValueError, "expected z to be BYTES_PER_FIELD_ELEMENT bytes");
+  if (PyBytes_Size(y) != BYTES_PER_FIELD_ELEMENT)
+    return PyErr_Format(PyExc_ValueError, "expected y to be BYTES_PER_FIELD_ELEMENT bytes");
+  if (PyBytes_Size(p) != BYTES_PER_PROOF)
+    return PyErr_Format(PyExc_ValueError, "expected proof to be BYTES_PER_PROOF bytes");
+
+  const Bytes48 *commitment_bytes = (Bytes48 *)PyBytes_AsString(c);
+  const Bytes32 *z_bytes = (Bytes32 *)PyBytes_AsString(z);
+  const Bytes32 *y_bytes = (Bytes32 *)PyBytes_AsString(y);
+  const Bytes48 *proof_bytes = (Bytes48 *)PyBytes_AsString(p);
+
+  bool ok;
+  if (verify_kzg_proof(&ok,
+        commitment_bytes, z_bytes, y_bytes, proof_bytes,
+        PyCapsule_GetPointer(s, "KZGSettings")) != C_KZG_OK) {
+    return PyErr_Format(PyExc_RuntimeError, "verify_kzg_proof failed");
+  }
+
+  if (ok) Py_RETURN_TRUE; else Py_RETURN_FALSE;
+}
+
+static PyObject* verify_blob_kzg_proof_wrap(PyObject *self, PyObject *args) {
+  PyObject *b, *c, *p, *s;
+
+  if (!PyArg_UnpackTuple(args, "verify_blob_kzg_proof", 4, 4, &b, &c, &p, &s) ||
+      !PyBytes_Check(b) ||
+      !PyBytes_Check(c) ||
+      !PyBytes_Check(p) ||
+      !PyCapsule_IsValid(s, "KZGSettings"))
+    return PyErr_Format(PyExc_ValueError,
+        "expected bytes, bytes, bytes, trusted setup");
+
+  if (PyBytes_Size(b) != BYTES_PER_BLOB)
+    return PyErr_Format(PyExc_ValueError, "expected blob to be BYTES_PER_BLOB bytes");
+  if (PyBytes_Size(c) != BYTES_PER_COMMITMENT)
+    return PyErr_Format(PyExc_ValueError, "expected commitment to be BYTES_PER_COMMITMENT bytes");
+  if (PyBytes_Size(p) != BYTES_PER_PROOF)
+    return PyErr_Format(PyExc_ValueError, "expected proof to be BYTES_PER_PROOF bytes");
+
+  const Blob *blob_bytes = (Blob *)PyBytes_AsString(b);
+  const Bytes48 *commitment_bytes = (Bytes48 *)PyBytes_AsString(c);
+  const Bytes48 *proof_bytes = (Bytes48 *)PyBytes_AsString(p);
+
+  bool ok;
+  if (verify_blob_kzg_proof(&ok,
+        blob_bytes, commitment_bytes, proof_bytes,
+        PyCapsule_GetPointer(s, "KZGSettings")) != C_KZG_OK) {
+    return PyErr_Format(PyExc_RuntimeError, "verify_blob_kzg_proof failed");
+  }
+
+  if (ok) Py_RETURN_TRUE; else Py_RETURN_FALSE;
+}
+
+static PyObject* verify_blob_kzg_proof_batch_wrap(PyObject *self, PyObject *args) {
+  PyObject *b, *c, *p, *s;
+
+  if (!PyArg_UnpackTuple(args, "verify_blob_kzg_proof_batch", 4, 4, &b, &c, &p, &s) ||
+      !PyBytes_Check(b) ||
+      !PyBytes_Check(c) ||
+      !PyBytes_Check(p) ||
+      !PyCapsule_IsValid(s, "KZGSettings"))
+    return PyErr_Format(PyExc_ValueError,
+        "expected bytes, bytes, bytes, trusted setup");
+
+  Py_ssize_t blobs_count = PyBytes_Size(b);
+  if (blobs_count % BYTES_PER_BLOB != 0)
+    return PyErr_Format(PyExc_ValueError, "expected blobs to be a multiple of BYTES_PER_BLOB bytes");
+  blobs_count = blobs_count / BYTES_PER_BLOB;
+
+  Py_ssize_t commitments_count = PyBytes_Size(c);
+  if (commitments_count % BYTES_PER_COMMITMENT != 0)
+    return PyErr_Format(PyExc_ValueError, "expected commitments to be a multiple of BYTES_PER_COMMITMENT bytes");
+  commitments_count = commitments_count / BYTES_PER_COMMITMENT;
+
+  Py_ssize_t proofs_count = PyBytes_Size(p);
+  if (proofs_count % BYTES_PER_PROOF != 0)
+    return PyErr_Format(PyExc_ValueError, "expected blobs to be a multiple of BYTES_PER_PROOF bytes");
+  proofs_count = proofs_count / BYTES_PER_PROOF;
+
+  if (blobs_count != commitments_count || blobs_count != proofs_count) {
+    return PyErr_Format(PyExc_ValueError, "expected same number of blobs/commitments/proofs");
+  }
+
+  const Blob *blobs_bytes = (Blob *)PyBytes_AsString(b);
+  const Bytes48 *commitments_bytes = (Bytes48 *)PyBytes_AsString(c);
+  const Bytes48 *proofs_bytes = (Bytes48 *)PyBytes_AsString(p);
+
+  bool ok;
+  if (verify_blob_kzg_proof_batch(&ok,
+        blobs_bytes, commitments_bytes, proofs_bytes, blobs_count,
+        PyCapsule_GetPointer(s, "KZGSettings")) != C_KZG_OK) {
+    return PyErr_Format(PyExc_RuntimeError, "verify_blob_kzg_proof_batch failed");
+  }
+
+  if (ok) Py_RETURN_TRUE; else Py_RETURN_FALSE;
+}
+
+static PyMethodDef ckzgmethods[] = {
+  {"load_trusted_setup",          load_trusted_setup_wrap,          METH_VARARGS, "Load trusted setup from file path"},
+  {"blob_to_kzg_commitment",      blob_to_kzg_commitment_wrap,      METH_VARARGS, "Create a commitment from a blob"},
+  {"compute_kzg_proof",           compute_kzg_proof_wrap,           METH_VARARGS, "Compute a proof for a blob/field"},
+  {"compute_blob_kzg_proof",      compute_blob_kzg_proof_wrap,      METH_VARARGS, "Compute a proof for a blob"},
+  {"verify_kzg_proof",            verify_kzg_proof_wrap,            METH_VARARGS, "Verify a proof for the given inputs"},
+  {"verify_blob_kzg_proof",       verify_blob_kzg_proof_wrap,       METH_VARARGS, "Verify a blob/commitment/proof combo"},
+  {"verify_blob_kzg_proof_batch", verify_blob_kzg_proof_batch_wrap, METH_VARARGS, "Verify multiple blob/commitment/proof combos"},
+  {NULL, NULL, 0, NULL}
+};
+
+static struct PyModuleDef ckzg = {
+  PyModuleDef_HEAD_INIT,
+  "ckzg",
+  NULL,
+  -1,
+  ckzgmethods
+};
+
+PyMODINIT_FUNC PyInit_ckzg(void) {
+    return PyModule_Create(&ckzg);
+}

ckzg-1.0.1/blst/.git

@@ -0,0 +1 @@
+gitdir: ../.git/modules/blst

ckzg-1.0.1/blst/.gitattributes

@@ -0,0 +1,3 @@
+*.pl linguist-language=assembly
+*.h linguist-language=c
+*.tgo linguist-language=go