Get compiling with CMake

src/rust_bindings/Cargo.toml

@@ -10,7 +10,8 @@ repository = "https://github.com/Chia-Network/chiavdf"
 links = "chiavdf"
 
 [dependencies]
+link-cplusplus = "1.0.9"
 
 [build-dependencies]
 bindgen = "0.69.4"
-cc = "1.0.90"
+cmake = "0.1.50"

src/rust_bindings/build.rs

@@ -1,8 +1,11 @@
 use std::env;
 use std::path::PathBuf;
+use std::str::FromStr;
+
+use cmake::Config;
 
 fn main() {
-    println!("cargo:rerun-if-changed=wrapper.cpp");
+    println!("cargo:rerun-if-changed=wrapper.hpp");
     println!("cargo:rustc-link-lib=gmp");
 
     let manifest_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR").unwrap());
@@ -11,23 +14,37 @@ fn main() {
     if !src_dir.exists() {
         src_dir = manifest_dir
             .parent()
-            .expect("can't access ../c_bindings")
-            .join("c_bindings");
+            .expect("can't access ../")
+            .to_path_buf();
     }
 
-    cc::Build::new()
-        .cpp(true)
-        .std("c++14")
-        .files([src_dir.join("c_wrapper.cpp")])
-        .warnings(false)
-        .include(src_dir.as_path())
-        .compile("chiavdf");
+    let dst = Config::new(src_dir.as_path())
+        .build_target("chiavdfc_static")
+        .define("BUILD_CHIAVDFC", "ON")
+        .env("BUILD_VDF_CLIENT", "N")
+        .define("BUILD_PYTHON", "OFF")
+        .build();
+
+    println!(
+        "cargo:rustc-link-search=native={}",
+        PathBuf::from_str(dst.display().to_string().as_str())
+            .unwrap()
+            .join("build")
+            .join("lib")
+            .join("static")
+            .to_str()
+            .unwrap()
+    );
+    println!("cargo:rustc-link-lib=static=chiavdfc");
 
     let bindings = bindgen::Builder::default()
         .header(manifest_dir.join("wrapper.hpp").to_str().unwrap())
         .clang_arg("-x")
         .clang_arg("c++")
-        .clang_arg(format!("-I{}", src_dir.to_str().unwrap()))
+        .clang_arg(format!(
+            "-I{}",
+            src_dir.join("c_bindings").to_str().unwrap()
+        ))
         .clang_arg("-std=c++14")
         .allowlist_function("verify_n_wesolowski_wrapper")
         .allowlist_function("create_discriminant_wrapper")

src/rust_bindings/src/main.rs

@@ -3,44 +3,34 @@
 #![allow(dead_code)]
 #![allow(non_upper_case_globals)]
 
+extern crate link_cplusplus;
+
 mod bindings {
     include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
 }
 
 fn main() {
-    // I have
-    // bindings::create_discriminant_wrapper(seed, seed_size, length)
-    // and
-    // bindings::verify_n_wesolowski_wrapper(discriminant_str, discriminant_size, x_s, x_s_size, proof_blob, proof_blob_size, num_iterations, disc_size_bits, recursion)
-    // in my bindings.rs
-    // generate some example code for using these in a test
-    // and print it out here
+    unsafe {
+        let discriminant = bindings::create_discriminant_wrapper([42; 10].as_ptr(), 10, 512);
+        println!("discriminant: {:?}", discriminant);
 
-    let seed = [0u8; 32];
-    let seed_size = 32;
-    let length = 1000;
-    let discriminant_size = 32;
-    let x_s = [0i8; 32];
-    let x_s_size = 32;
-    let proof_blob = [0i8; 32];
-    let proof_blob_size = 32;
-    let num_iterations = 10;
-    let disc_size_bits = 32;
-    let recursion = 0;
+        let mut initial_el = [0i8; 100];
+        initial_el[0] = 0x08;
 
-    unsafe {
-        let discriminant = bindings::create_discriminant_wrapper(seed.as_ptr(), seed_size, length);
-        let result = bindings::verify_n_wesolowski_wrapper(
+        let bytes = [0; 100];
+
+        let valid = bindings::verify_n_wesolowski_wrapper(
             discriminant,
-            discriminant_size,
-            x_s.as_ptr(),
-            x_s_size,
-            proof_blob.as_ptr(),
-            proof_blob_size,
-            num_iterations,
-            disc_size_bits,
-            recursion,
+            512,
+            initial_el.as_ptr(),
+            initial_el.len(),
+            bytes.as_ptr(),
+            bytes.len(),
+            100000,
+            32,
+            32,
         );
-        println!("result: {}", result);
+
+        println!("valid: {:?}", valid);
     }
 }