Make Rust bindgen build dependency optional

Now that header definitions are stable across builds (#377), we can remove the
Rust `bindgen` build dependency by gating it to an optional feature. This also
transitively removes the dependency on `libclang` for Rust bindings.

bindings/rust/Cargo.toml

@@ -11,20 +11,21 @@ links = "ckzg"
 default = ["std"]
 std = ["hex/std", "libc/std", "serde?/std"]
 serde = ["dep:serde"]
+generate_bindings = ["dep:bindgen"]
 
 # BLST Compilation:
 # Suppress multi-threading.
 # Engaged on wasm32 target architecture automatically.
 no-threads = []
 
 [dependencies]
+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 }
 serde = { version = "1.0", optional = true, default-features = false, features = [
     "alloc",
     "derive",
 ] }
-blst = { version = "0.3.11", default-features = false }
 
 [dev-dependencies]
 criterion = "0.5.1"
@@ -35,7 +36,7 @@ serde_yaml = "0.9.17"
 serde_json = "1.0.105"
 
 [build-dependencies]
-bindgen = "0.66.1"
+bindgen = { version = "0.69", optional = true }
 cc = "1.0"
 
 [target.'cfg(target_env = "msvc")'.build-dependencies]

bindings/rust/build.rs

@@ -34,28 +34,23 @@ fn main() {
 
     cc.try_compile("ckzg").expect("Failed to compile ckzg");
 
-    let out_dir = PathBuf::from(env::var("OUT_DIR").unwrap());
-    let bindings_out_path = out_dir.join("generated.rs");
-    let header_file_path = c_src_dir.join("c_kzg_4844.h");
-    let header_file = header_file_path.to_str().expect("valid header file");
-
-    make_bindings(
-        header_file,
-        &blst_headers_dir.to_string_lossy(),
-        bindings_out_path,
-    );
+    #[cfg(feature = "generate_bindings")]
+    {
+        let header_path = c_src_dir.join("c_kzg_4844.h");
+        let bindings_out_path = concat!(env!("CARGO_MANIFEST_DIR"), "/src/bindings/generated.rs");
+        make_bindings(
+            header_path.to_str().expect("valid header path"),
+            blst_headers_dir.to_str().expect("valid blst header path"),
+            bindings_out_path.as_ref(),
+        );
+    }
 
     // Finally, tell cargo this provides ckzg/ckzg_min
     println!("cargo:rustc-link-lib=ckzg");
 }
 
-fn make_bindings<P>(
-    header_path: &str,
-    blst_headers_dir: &str,
-    bindings_out_path: P,
-) where
-    P: AsRef<std::path::Path>,
-{
+#[cfg(feature = "generate_bindings")]
+fn make_bindings(header_path: &str, blst_headers_dir: &str, bindings_out_path: &std::path::Path) {
     use bindgen::Builder;
 
     #[derive(Debug)]
@@ -122,7 +117,7 @@ fn make_bindings<P>(
         /*
          * Re-build instructions
          */
-        .parse_callbacks(Box::new(bindgen::CargoCallbacks))
+        .parse_callbacks(Box::new(bindgen::CargoCallbacks::new()))
         .generate()
         .unwrap();
 

bindings/rust/src/bindings/generated.rs

@@ -0,0 +1,138 @@
+/* automatically generated by rust-bindgen 0.69.1 */
+
+use libc::FILE;
+
+pub const BYTES_PER_COMMITMENT: usize = 48;
+pub const BYTES_PER_PROOF: usize = 48;
+pub const BYTES_PER_FIELD_ELEMENT: usize = 32;
+pub const FIELD_ELEMENTS_PER_BLOB: usize = 4096;
+pub const BYTES_PER_BLOB: usize = 131072;
+pub type limb_t = u64;
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct blst_fr {
+    l: [limb_t; 4usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct blst_fp {
+    l: [limb_t; 6usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct blst_fp2 {
+    fp: [blst_fp; 2usize],
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct blst_p1 {
+    x: blst_fp,
+    y: blst_fp,
+    z: blst_fp,
+}
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct blst_p2 {
+    x: blst_fp2,
+    y: blst_fp2,
+    z: blst_fp2,
+}
+pub type g1_t = blst_p1;
+pub type g2_t = blst_p2;
+pub type fr_t = blst_fr;
+#[doc = " An array of 32 bytes. Represents an untrusted\n (potentially invalid) field element."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct Bytes32 {
+    bytes: [u8; 32usize],
+}
+#[doc = " An array of 48 bytes. Represents an untrusted\n (potentially invalid) commitment/proof."]
+#[repr(C)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub struct Bytes48 {
+    bytes: [u8; 48usize],
+}
+#[doc = " A basic blob data."]
+#[repr(C)]
+#[derive(Debug, PartialEq, Eq)]
+pub struct Blob {
+    bytes: [u8; 131072usize],
+}
+#[repr(u32)]
+#[doc = " The common return type for all routines in which something can go wrong."]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
+pub enum C_KZG_RET {
+    #[doc = "< Success!"]
+    C_KZG_OK = 0,
+    #[doc = "< The supplied data is invalid in some way."]
+    C_KZG_BADARGS = 1,
+    #[doc = "< Internal error - this should never occur."]
+    C_KZG_ERROR = 2,
+    #[doc = "< Could not allocate memory."]
+    C_KZG_MALLOC = 3,
+}
+#[doc = " Stores the setup and parameters needed for computing KZG proofs."]
+#[repr(C)]
+#[derive(Debug, PartialEq, Eq)]
+pub struct KZGSettings {
+    #[doc = " The length of `roots_of_unity`, a power of 2."]
+    max_width: u64,
+    #[doc = " Powers of the primitive root of unity determined by\n `SCALE2_ROOT_OF_UNITY` in bit-reversal permutation order,\n length `max_width`."]
+    roots_of_unity: *mut fr_t,
+    #[doc = " G1 group elements from the trusted setup,\n in Lagrange form bit-reversal permutation."]
+    g1_values: *mut g1_t,
+    #[doc = " G2 group elements from the trusted setup."]
+    g2_values: *mut g2_t,
+}
+extern "C" {
+    pub fn load_trusted_setup(
+        out: *mut KZGSettings,
+        g1_bytes: *const u8,
+        n1: usize,
+        g2_bytes: *const u8,
+        n2: usize,
+    ) -> C_KZG_RET;
+    pub fn load_trusted_setup_file(out: *mut KZGSettings, in_: *mut FILE) -> C_KZG_RET;
+    pub fn free_trusted_setup(s: *mut KZGSettings);
+    pub fn blob_to_kzg_commitment(
+        out: *mut KZGCommitment,
+        blob: *const Blob,
+        s: *const KZGSettings,
+    ) -> C_KZG_RET;
+    pub fn compute_kzg_proof(
+        proof_out: *mut KZGProof,
+        y_out: *mut Bytes32,
+        blob: *const Blob,
+        z_bytes: *const Bytes32,
+        s: *const KZGSettings,
+    ) -> C_KZG_RET;
+    pub fn compute_blob_kzg_proof(
+        out: *mut KZGProof,
+        blob: *const Blob,
+        commitment_bytes: *const Bytes48,
+        s: *const KZGSettings,
+    ) -> C_KZG_RET;
+    pub fn verify_kzg_proof(
+        ok: *mut bool,
+        commitment_bytes: *const Bytes48,
+        z_bytes: *const Bytes32,
+        y_bytes: *const Bytes32,
+        proof_bytes: *const Bytes48,
+        s: *const KZGSettings,
+    ) -> C_KZG_RET;
+    pub fn verify_blob_kzg_proof(
+        ok: *mut bool,
+        blob: *const Blob,
+        commitment_bytes: *const Bytes48,
+        proof_bytes: *const Bytes48,
+        s: *const KZGSettings,
+    ) -> C_KZG_RET;
+    pub fn verify_blob_kzg_proof_batch(
+        ok: *mut bool,
+        blobs: *const Blob,
+        commitments_bytes: *const Bytes48,
+        proofs_bytes: *const Bytes48,
+        n: usize,
+        s: *const KZGSettings,
+    ) -> C_KZG_RET;
+}

bindings/rust/src/bindings/mod.rs

@@ -1,13 +1,11 @@
-#![allow(non_upper_case_globals)]
-#![allow(non_camel_case_types)]
-#![allow(non_snake_case)]
+#![allow(non_camel_case_types, non_snake_case, non_upper_case_globals)]
 
 #[cfg(feature = "serde")]
 mod serde;
 #[cfg(test)]
 mod test_formats;
 
-include!(concat!(env!("OUT_DIR"), "/generated.rs"));
+include!("./generated.rs");
 
 use alloc::string::String;
 use alloc::vec::Vec;