napi: uniformize format to match plonk-wasm side

Author: querolita

plonk-napi/src/poly_comm.rs

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