napi: impls for polycomm

Author: querolita

plonk-napi/src/lib.rs

@@ -1,12 +1,13 @@
 pub(crate) mod poseidon;
 pub(crate) mod wrappers;
 pub(crate) mod wasm_vector;
+pub(crate) mod poly_comm;
 
 pub use poseidon::{
     caml_pasta_fp_poseidon_block_cipher,
     caml_pasta_fq_poseidon_block_cipher,
 };
 
-pub use wrappers::field::{WasmPastaFp, WasmPastaFq};
 pub use wrappers::group::{WasmGPallas, WasmGVesta};
 pub use wasm_vector::{fp::WasmVecVecFp, fq::WasmVecVecFq};
+pub use poly_comm::{pallas::WasmFqPolyComm, vesta::WasmFpPolyComm};

plonk-napi/src/poly_comm.rs

@@ -1,11 +1,14 @@
-use crate::wasm_vector::WasmVector;
+use crate::{
+    wrappers::group::{WasmGPallas, WasmGVesta},
+    wasm_vector::WasmVector,
+};
 use napi_derive::napi;
 use paste::paste;
 use poly_commitment::commitment::PolyComm;
 
 macro_rules! impl_poly_comm {
     (
-        $WasmG:ty,
+        $wasm_g:ty,
         $g:ty,
         $field_name:ident
     ) => {
@@ -14,14 +17,14 @@ macro_rules! impl_poly_comm {
             #[derive(Clone)]
             pub struct [<Wasm $field_name:camel PolyComm>] {
                 #[napi(skip)]
-                pub unshifted: WasmVector<$WasmG>,
-                pub shifted: Option<$WasmG>,
+                pub unshifted: WasmVector<$wasm_g>,
+                pub shifted: Option<$wasm_g>,
             }
 
             #[napi]
             impl [<Wasm $field_name:camel PolyComm>] {
                 #[napi(constructor)]
-                pub fn new(unshifted: WasmVector<$WasmG>, shifted: Option<$WasmG>) -> Self {
+                pub fn new(unshifted: WasmVector<$wasm_g>, shifted: Option<$wasm_g>) -> Self {
                     assert!(
                         shifted.is_none(),
                         "mina#14628: Shifted commitments are deprecated and must not be used",
@@ -30,20 +33,20 @@ macro_rules! impl_poly_comm {
                 }
 
                 #[napi(getter)]
-                pub fn unshifted(&self) -> WasmVector<$WasmG> {
+                pub fn unshifted(&self) -> WasmVector<$wasm_g> {
                     self.unshifted.clone()
                 }
 
                 #[napi(setter)]
-                pub fn set_unshifted(&mut self, x: WasmVector<$WasmG>) {
-                    self.unshifted = x;
+                pub fn set_unshifted(&mut self, value: WasmVector<$wasm_g>) {
+                    self.unshifted = value;
                 }
             }
 
             impl From<PolyComm<$g>> for [<Wasm $field_name:camel PolyComm>] {
-                fn from(x: PolyComm<$g>) -> Self {
-                    let PolyComm { chunks } = x;
-                    let unshifted: Vec<$WasmG> = chunks.into_iter().map(Into::into).collect();
+                fn from(value: PolyComm<$g>) -> Self {
+                    let PolyComm { chunks } = value;
+                    let unshifted: Vec<$wasm_g> = chunks.into_iter().map(Into::into).collect();
                     Self {
                         unshifted: unshifted.into(),
                         shifted: None,
@@ -52,8 +55,8 @@ macro_rules! impl_poly_comm {
             }
 
             impl From<&PolyComm<$g>> for [<Wasm $field_name:camel PolyComm>] {
-                fn from(x: &PolyComm<$g>) -> Self {
-                    let unshifted: Vec<$WasmG> = x.chunks.iter().map(|chunk| (*chunk).into()).collect();
+                fn from(value: &PolyComm<$g>) -> Self {
+                    let unshifted: Vec<$wasm_g> = value.chunks.iter().map(|chunk| (*chunk).into()).collect();
                     Self {
                         unshifted: unshifted.into(),
                         shifted: None,
@@ -62,14 +65,14 @@ macro_rules! impl_poly_comm {
             }
 
             impl From<[<Wasm $field_name:camel PolyComm>]> for PolyComm<$g> {
-                fn from(x: [<Wasm $field_name:camel PolyComm>]) -> Self {
-                    let [<Wasm $field_name:camel PolyComm>] { unshifted, shifted } = x;
+                fn from(value: [<Wasm $field_name:camel PolyComm>]) -> Self {
+                    let [<Wasm $field_name:camel PolyComm>] { unshifted, shifted } = value;
                     assert!(
                         shifted.is_none(),
                         "mina#14628: Shifted commitments are deprecated and must not be used",
                     );
                     PolyComm {
-                        chunks: Vec::<$WasmG>::from(unshifted)
+                        chunks: Vec::<$wasm_g>::from(unshifted)
                             .into_iter()
                             .map(Into::into)
                             .collect(),
@@ -78,13 +81,13 @@ macro_rules! impl_poly_comm {
             }
 
             impl From<&[<Wasm $field_name:camel PolyComm>]> for PolyComm<$g> {
-                fn from(x: &[<Wasm $field_name:camel PolyComm>]) -> Self {
+                fn from(value: &[<Wasm $field_name:camel PolyComm>]) -> Self {
                     assert!(
-                        x.shifted.is_none(),
+                        value.shifted.is_none(),
                         "mina#14628: Shifted commitments are deprecated and must not be used",
                     );
                     PolyComm {
-                        chunks: x
+                        chunks: value
                             .unshifted
                             .iter()
                             .cloned()
@@ -99,15 +102,13 @@ macro_rules! impl_poly_comm {
 
 pub mod pallas {
     use super::*;
-    use crate::wrappers::group::WasmGPallas;
     use mina_curves::pasta::Pallas as GAffine;
 
     impl_poly_comm!(WasmGPallas, GAffine, Fq);
 }
 
 pub mod vesta {
     use super::*;
-    use crate::wrappers::group::WasmGVesta;
     use mina_curves::pasta::Vesta as GAffine;
 
     impl_poly_comm!(WasmGVesta, GAffine, Fp);