plonk-neon: Add new crate for nodejs

Author: richardpringle

Cargo.lock

@@ -14,6 +14,7 @@ members = [
   "msm",
   "mvpoly",
   "o1vm",
+  "plonk-neon",
   "plonk-wasm",
   "poly-commitment",
   "poseidon",

Cargo.toml

@@ -0,0 +1,44 @@
+[package]
+name = "plonk_neon"
+version = "0.1.0"
+authors = ["[email protected]"]
+description = "Neon module for plonk proof systems"
+repository = "https://github.com/MinaProtocol/mina"
+license = "MIT/Apache-2.0"
+edition = "2021"
+
+[lib]
+name = "plonk_neon"
+crate-type = ["cdylib"]
+
+################################# Dependencies ################################
+
+[dependencies]
+# Strictly enforcing 0.2.87
+
+libc = "0.2.62"
+once_cell = "1.10.0"
+
+# arkworks
+ark-ec.workspace = true
+ark-ff.workspace = true
+ark-poly.workspace = true
+ark-serialize.workspace = true
+arkworks.workspace = true
+
+# proof-systems
+mina-curves = { path = "../curves" }
+mina-poseidon = { path = "../poseidon" }
+o1-utils = { path = "../utils" }
+
+getrandom.workspace = true
+neon = { version = "1.0.0" }
+num-bigint.workspace = true
+paste.workspace = true
+rand.workspace = true
+rayon.workspace = true
+rmp-serde.workspace = true
+serde.workspace = true
+serde_with.workspace = true
+wasm-bindgen.workspace = true
+wasm-types.workspace = true

plonk-neon/Cargo.toml

@@ -0,0 +1,29 @@
+//! This module contains wrapper types to Arkworks types.
+//! To use Arkwork types in OCaml, you have to convert to these types,
+//! and convert back from them to use them in Rust.
+//!
+//! For example:
+//!
+//! ```
+//! use marlin_plonk_bindings::arkworks::CamlBiginteger256;
+//! use ark_ff::BigInteger256;
+//!
+//! #[ocaml::func]
+//! pub fn caml_add(x: CamlBigInteger256, y: CamlBigInteger256) -> CamlBigInteger256 {
+//!    let x: BigInteger256 = x.into();
+//!    let y: BigInteger256 = y.into();
+//!    (x + y).into()
+//! }
+//! ```
+//!
+
+mod bigint_256;
+mod group_affine;
+mod group_projective;
+mod pasta_fp;
+mod pasta_fq;
+
+// re-export what's important
+
+pub use pasta_fp::WasmPastaFp;
+pub use pasta_fq::WasmPastaFq;

plonk-neon/src/arkworks.rs

@@ -0,0 +1,147 @@
+use ark_ff::{BigInt, BigInteger as ark_BigInteger, BigInteger256};
+use ark_serialize::{CanonicalDeserialize, CanonicalSerialize, Write};
+use num_bigint::BigUint;
+use std::{
+    cmp::Ordering::{Equal, Greater, Less},
+    convert::TryInto,
+};
+use wasm_bindgen::{
+    convert::{FromWasmAbi, IntoWasmAbi},
+    prelude::*,
+};
+
+//
+// Handy constants
+//
+
+const BIGINT256_NUM_BITS: i32 = 256;
+const BIGINT256_LIMB_BITS: i32 = 64;
+const BIGINT256_LIMB_BYTES: i32 = BIGINT256_LIMB_BITS / 8;
+const BIGINT256_NUM_LIMBS: i32 =
+    (BIGINT256_NUM_BITS + BIGINT256_LIMB_BITS - 1) / BIGINT256_LIMB_BITS;
+const BIGINT256_NUM_BYTES: usize = (BIGINT256_NUM_LIMBS as usize) * 8;
+
+pub struct WasmBigInteger256(pub BigInteger256);
+
+impl wasm_bindgen::describe::WasmDescribe for WasmBigInteger256 {
+    fn describe() {
+        <Vec<u8> as wasm_bindgen::describe::WasmDescribe>::describe()
+    }
+}
+
+impl FromWasmAbi for WasmBigInteger256 {
+    type Abi = <Vec<u8> as FromWasmAbi>::Abi;
+    unsafe fn from_abi(js: Self::Abi) -> Self {
+        let bytes: Vec<u8> = FromWasmAbi::from_abi(js);
+        // TODO this used FromBytes before arkworks 0.4.2, check serialization is consistent after update
+        WasmBigInteger256(BigInteger256::deserialize_compressed(bytes.as_slice()).unwrap())
+    }
+}
+
+impl IntoWasmAbi for WasmBigInteger256 {
+    type Abi = <Vec<u8> as FromWasmAbi>::Abi;
+    fn into_abi(self) -> Self::Abi {
+        let mut bytes: Vec<u8> = vec![];
+        bytes.write_all(self.0.to_bytes_le().as_slice()).unwrap();
+        bytes.into_abi()
+    }
+}
+
+pub fn to_biguint(x: &BigInteger256) -> BigUint {
+    let x_ = x.0.as_ptr() as *const u8;
+    let x_ = unsafe { std::slice::from_raw_parts(x_, BIGINT256_NUM_BYTES) };
+    num_bigint::BigUint::from_bytes_le(x_)
+}
+
+pub fn of_biguint(x: &BigUint) -> BigInteger256 {
+    let mut bytes = x.to_bytes_le();
+    bytes.resize(BIGINT256_NUM_BYTES, 0);
+    let limbs = bytes.as_ptr();
+    let limbs = limbs as *const [u64; BIGINT256_NUM_LIMBS as usize];
+    let limbs = unsafe { &(*limbs) };
+    BigInt(*limbs)
+}
+
+#[wasm_bindgen]
+pub fn caml_bigint_256_of_numeral(s: String, _len: u32, base: u32) -> WasmBigInteger256 {
+    match BigUint::parse_bytes(&s.into_bytes(), base) {
+        Some(data) => WasmBigInteger256(of_biguint(&data)),
+        None => panic!("caml_bigint_256_of_numeral"),
+    }
+}
+
+#[wasm_bindgen]
+pub fn caml_bigint_256_of_decimal_string(s: String) -> WasmBigInteger256 {
+    match BigUint::parse_bytes(&s.into_bytes(), 10) {
+        Some(data) => WasmBigInteger256(of_biguint(&data)),
+        None => panic!("caml_bigint_256_of_decimal_string"),
+    }
+}
+
+#[wasm_bindgen]
+pub fn caml_bigint_256_num_limbs() -> i32 {
+    BIGINT256_NUM_LIMBS
+}
+
+#[wasm_bindgen]
+pub fn caml_bigint_256_bytes_per_limb() -> i32 {
+    BIGINT256_LIMB_BYTES
+}
+
+#[wasm_bindgen]
+pub fn caml_bigint_256_div(x: WasmBigInteger256, y: WasmBigInteger256) -> WasmBigInteger256 {
+    let res: BigUint = to_biguint(&x.0) / to_biguint(&y.0);
+    WasmBigInteger256(of_biguint(&res))
+}
+
+#[wasm_bindgen]
+pub fn caml_bigint_256_compare(x: WasmBigInteger256, y: WasmBigInteger256) -> i8 {
+    match x.0.cmp(&y.0) {
+        Less => -1,
+        Equal => 0,
+        Greater => 1,
+    }
+}
+
+#[wasm_bindgen]
+pub fn caml_bigint_256_print(x: WasmBigInteger256) {
+    println!("{}", to_biguint(&x.0));
+}
+
+#[wasm_bindgen]
+pub fn caml_bigint_256_to_string(x: WasmBigInteger256) -> String {
+    to_biguint(&x.0).to_string()
+}
+
+#[wasm_bindgen]
+pub fn caml_bigint_256_test_bit(x: WasmBigInteger256, i: i32) -> bool {
+    match i.try_into() {
+        Ok(i) => x.0.get_bit(i),
+        Err(_) => panic!("caml_bigint_256_test_bit"),
+    }
+}
+
+#[wasm_bindgen]
+pub fn caml_bigint_256_to_bytes(x: WasmBigInteger256) -> Vec<u8> {
+    let mut serialized_bytes = vec![];
+    x.0.serialize_compressed(&mut serialized_bytes)
+        .expect("serialize failed");
+    serialized_bytes
+}
+
+#[wasm_bindgen]
+pub fn caml_bigint_256_of_bytes(x: &[u8]) -> WasmBigInteger256 {
+    let len = std::mem::size_of::<WasmBigInteger256>();
+    if x.len() != len {
+        panic!("caml_bigint_256_of_bytes");
+    };
+    // TODO this used FromBytes before arkworks 0.4.2, check serialization is consistent after update
+    WasmBigInteger256(
+        BigInteger256::deserialize_compressed(&mut &x[..]).expect("deserialization error"),
+    )
+}
+
+#[wasm_bindgen]
+pub fn caml_bigint_256_deep_copy(x: WasmBigInteger256) -> WasmBigInteger256 {
+    x
+}