From 8cbe0a32a329944f46dfbd7e06f9cde1ea0b165b Mon Sep 17 00:00:00 2001
From: Vu Vo <vu.voth@gmail.com>
Date: Wed, 8 May 2024 18:21:32 +0700
Subject: [PATCH 1/6] first step from state to vector macro

---
 Cargo.toml                     |  3 ++-
 frontend-macro/Cargo.toml      | 20 +++++++++++++++
 frontend-macro/src/lib.rs      | 47 ++++++++++++++++++++++++++++++++++
 frontend-macro/src/main.rs     | 20 +++++++++++++++
 frontend-macro/tests/parse.rs  | 10 ++++++++
 frontend-macro/tests/runner.rs |  5 ++++
 6 files changed, 104 insertions(+), 1 deletion(-)
 create mode 100644 frontend-macro/Cargo.toml
 create mode 100644 frontend-macro/src/lib.rs
 create mode 100644 frontend-macro/src/main.rs
 create mode 100644 frontend-macro/tests/parse.rs
 create mode 100644 frontend-macro/tests/runner.rs

diff --git a/Cargo.toml b/Cargo.toml
index 8445a188a..040724e1c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,7 +2,8 @@
 members = [
     "folding-schemes",
     "solidity-verifiers",
-    "cli"
+    "cli",
+    "frontend-macro"
 ]
 resolver = "2"
 
diff --git a/frontend-macro/Cargo.toml b/frontend-macro/Cargo.toml
new file mode 100644
index 000000000..8d03a1a56
--- /dev/null
+++ b/frontend-macro/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "frontend-macro"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+syn = { version = "0.15", features = ["extra-traits"] }
+quote = "0.6"
+proc-macro2 = "0.4"
+ark-ff = "^0.4.0"
+ark-bn254 = {version="0.4.0", features=["r1cs"]}
+
+
+[dev-dependencies]
+trybuild = "1.0"
+
+[lib]
+proc-macro = true
\ No newline at end of file
diff --git a/frontend-macro/src/lib.rs b/frontend-macro/src/lib.rs
new file mode 100644
index 000000000..011112466
--- /dev/null
+++ b/frontend-macro/src/lib.rs
@@ -0,0 +1,47 @@
+use proc_macro::TokenStream;
+use quote::{quote, ToTokens};
+use syn::{parse_macro_input, DeriveInput};
+
+
+
+#[proc_macro_derive(Flatten)]
+pub fn derive(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+    let iden = &ast.ident;
+
+    let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
+    
+    let fields = if let syn::Data::Struct(syn::DataStruct {
+        fields: syn::Fields::Named(syn::FieldsNamed { ref named, .. }),
+        ..
+    }) = ast.data
+    {
+        named
+    } else {
+        unimplemented!();
+    };
+
+    
+    let builder_fields = fields.iter().map(|f| {
+        let name = &f.ident;
+        quote! { value.#name }
+        
+    });
+
+    let expanded = quote! {
+        impl #impl_generics From<#iden #ty_generics> for Vec #ty_generics #where_clause {
+            fn from(value: #iden #ty_generics) -> Vec #ty_generics {
+                vec![#(#builder_fields,)*]
+            }
+        }
+
+        // impl #impl_generics From<Vec #ty_generics> for #iden #ty_generics {
+        //     fn from(vec: Vec #ty_generics) -> #iden #ty_generics{
+
+        //     }
+        // }
+    };
+    expanded.into()
+}
+
+
diff --git a/frontend-macro/src/main.rs b/frontend-macro/src/main.rs
new file mode 100644
index 000000000..f3c0c15f5
--- /dev/null
+++ b/frontend-macro/src/main.rs
@@ -0,0 +1,20 @@
+use ark_bn254::Fr;
+use ark_ff::PrimeField;
+use frontend_macro::Flatten;
+
+#[derive(Flatten)]
+struct State<F: PrimeField> {
+    a: F,
+    b: F
+}
+
+fn main() {
+    let s = State::<Fr> {
+        a: Fr::from(1u32),
+        b: Fr::from(1u32)
+    };
+
+    let v: Vec<Fr> = Vec::from(s);
+
+    println!("{:?}", v);
+}
\ No newline at end of file
diff --git a/frontend-macro/tests/parse.rs b/frontend-macro/tests/parse.rs
new file mode 100644
index 000000000..e4b08acac
--- /dev/null
+++ b/frontend-macro/tests/parse.rs
@@ -0,0 +1,10 @@
+use frontend_macro::Flatten;
+
+#[derive(Flatten)]
+struct State<F: > {
+    a: F
+}
+
+fn main() {
+
+}
\ No newline at end of file
diff --git a/frontend-macro/tests/runner.rs b/frontend-macro/tests/runner.rs
new file mode 100644
index 000000000..26917f3fe
--- /dev/null
+++ b/frontend-macro/tests/runner.rs
@@ -0,0 +1,5 @@
+#[test]
+fn tests() {
+    let t = trybuild::TestCases::new();
+    t.pass("tests/parse.rs");
+}

From b46092cc2740a2ec970fe08b0df6514170ac38fe Mon Sep 17 00:00:00 2001
From: Vu Vo <vu.voth@gmail.com>
Date: Wed, 8 May 2024 23:47:18 +0700
Subject: [PATCH 2/6] add from vec to state

---
 examples/multi_inputs.rs      | 29 ++++++++++++++++++++++-------
 folding-schemes/Cargo.toml    |  1 +
 frontend-macro/src/lib.rs     | 31 +++++++++++++++++++++++--------
 frontend-macro/src/main.rs    |  4 +++-
 frontend-macro/tests/parse.rs |  3 ++-
 5 files changed, 51 insertions(+), 17 deletions(-)

diff --git a/examples/multi_inputs.rs b/examples/multi_inputs.rs
index bb1508291..f2da6964b 100644
--- a/examples/multi_inputs.rs
+++ b/examples/multi_inputs.rs
@@ -8,6 +8,7 @@ use ark_r1cs_std::alloc::AllocVar;
 use ark_r1cs_std::fields::fp::FpVar;
 use ark_relations::r1cs::{ConstraintSystemRef, SynthesisError};
 use core::marker::PhantomData;
+use frontend_macro::Flatten;
 use std::time::Instant;
 
 use ark_bn254::{constraints::GVar, Bn254, Fr, G1Projective as Projective};
@@ -25,6 +26,17 @@ use utils::init_nova_ivc_params;
 /// we get by applying the step.
 /// In this example we set z_i and z_{i+1} to have five elements, and at each step we do different
 /// operations on each of them.
+///
+
+#[derive(Flatten)]
+pub struct State<F: PrimeField> {
+    pub a: F,
+    pub b: F,
+    pub c: F,
+    pub d: F,
+    pub e: F,
+}
+
 #[derive(Clone, Copy, Debug)]
 pub struct MultiInputsFCircuit<F: PrimeField> {
     _f: PhantomData<F>,
@@ -50,13 +62,16 @@ impl<F: PrimeField> FCircuit<F> for MultiInputsFCircuit<F> {
         z_i: Vec<F>,
         _external_inputs: Vec<F>,
     ) -> Result<Vec<F>, Error> {
-        let a = z_i[0] + F::from(4_u32);
-        let b = z_i[1] + F::from(40_u32);
-        let c = z_i[2] * F::from(4_u32);
-        let d = z_i[3] * F::from(40_u32);
-        let e = z_i[4] + F::from(100_u32);
-
-        Ok(vec![a, b, c, d, e])
+        let state = State::from(z_i);
+
+        let next_state = State {
+            a: state.a + F::from(4_u32),
+            b: state.b + F::from(40_u32),
+            c: state.c * F::from(4_u32),
+            d: state.d * F::from(40_u32),
+            e: state.e + F::from(100_u32),
+        };
+        Ok(Vec::from(next_state))
     }
 
     /// generates the constraints for the step of F for the given z_i
diff --git a/folding-schemes/Cargo.toml b/folding-schemes/Cargo.toml
index 964a633d2..678aff433 100644
--- a/folding-schemes/Cargo.toml
+++ b/folding-schemes/Cargo.toml
@@ -22,6 +22,7 @@ num-integer = "0.1"
 color-eyre = "=0.6.2"
 ark-bn254 = {version="0.4.0"}
 ark-groth16 = { version = "^0.4.0" }
+frontend-macro = { path = "../frontend-macro/"}
 
 # tmp imports for espresso's sumcheck
 espresso_subroutines = {git="https://github.com/EspressoSystems/hyperplonk", package="subroutines"}
diff --git a/frontend-macro/src/lib.rs b/frontend-macro/src/lib.rs
index 011112466..dc9a4b73f 100644
--- a/frontend-macro/src/lib.rs
+++ b/frontend-macro/src/lib.rs
@@ -1,9 +1,8 @@
 use proc_macro::TokenStream;
-use quote::{quote, ToTokens};
+use quote::quote;
 use syn::{parse_macro_input, DeriveInput};
 
 
-
 #[proc_macro_derive(Flatten)]
 pub fn derive(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
@@ -25,21 +24,37 @@ pub fn derive(input: TokenStream) -> TokenStream {
     let builder_fields = fields.iter().map(|f| {
         let name = &f.ident;
         quote! { value.#name }
-        
     });
 
+    let vec_to_fields = fields.iter().enumerate().map(|(id, f)| {
+        let name = &f.ident;
+        quote! {#name: vec[#id]}
+    });
+
+    let state_number = fields.len();
+
     let expanded = quote! {
+        
+        impl #impl_generics #iden #ty_generics #where_clause {
+            pub fn state_number() -> usize {
+                #state_number
+            }
+        }
+
         impl #impl_generics From<#iden #ty_generics> for Vec #ty_generics #where_clause {
             fn from(value: #iden #ty_generics) -> Vec #ty_generics {
                 vec![#(#builder_fields,)*]
             }
         }
 
-        // impl #impl_generics From<Vec #ty_generics> for #iden #ty_generics {
-        //     fn from(vec: Vec #ty_generics) -> #iden #ty_generics{
-
-        //     }
-        // }
+        impl #impl_generics From<Vec #ty_generics> for #iden #ty_generics {
+            fn from(vec: Vec #ty_generics) -> #iden #ty_generics {
+                assert!(vec.len() == #iden::#ty_generics::state_number());
+                #iden {
+                    #(#vec_to_fields,)*
+                }               
+            }
+        }
     };
     expanded.into()
 }
diff --git a/frontend-macro/src/main.rs b/frontend-macro/src/main.rs
index f3c0c15f5..9f881cde5 100644
--- a/frontend-macro/src/main.rs
+++ b/frontend-macro/src/main.rs
@@ -2,7 +2,7 @@ use ark_bn254::Fr;
 use ark_ff::PrimeField;
 use frontend_macro::Flatten;
 
-#[derive(Flatten)]
+#[derive(Flatten, Debug)]
 struct State<F: PrimeField> {
     a: F,
     b: F
@@ -16,5 +16,7 @@ fn main() {
 
     let v: Vec<Fr> = Vec::from(s);
 
+    println!("{:?}", State::<Fr>::state_number());
     println!("{:?}", v);
+    println!("{:?}", State::from(v));
 }
\ No newline at end of file
diff --git a/frontend-macro/tests/parse.rs b/frontend-macro/tests/parse.rs
index e4b08acac..5b07f1ea4 100644
--- a/frontend-macro/tests/parse.rs
+++ b/frontend-macro/tests/parse.rs
@@ -1,7 +1,8 @@
+use ark_ff::PrimeField;
 use frontend_macro::Flatten;
 
 #[derive(Flatten)]
-struct State<F: > {
+struct State<F: PrimeField> {
     a: F
 }
 

From fa7b82307b6c67d8e0ffff92d930104624e8daf3 Mon Sep 17 00:00:00 2001
From: Vu Vo <vu.voth@gmail.com>
Date: Sat, 11 May 2024 22:26:49 +0700
Subject: [PATCH 3/6] constraint system macro

---
 examples/multi_inputs.rs      | 21 +++++++++-----
 frontend-macro/Cargo.toml     |  2 +-
 frontend-macro/src/lib.rs     | 53 +++++++++++++++++++++++++++++++++--
 frontend-macro/src/main.rs    |  1 -
 frontend-macro/tests/parse.rs | 16 +++++++++--
 5 files changed, 78 insertions(+), 15 deletions(-)

diff --git a/examples/multi_inputs.rs b/examples/multi_inputs.rs
index f2da6964b..170b75823 100644
--- a/examples/multi_inputs.rs
+++ b/examples/multi_inputs.rs
@@ -47,9 +47,11 @@ impl<F: PrimeField> FCircuit<F> for MultiInputsFCircuit<F> {
     fn new(_params: Self::Params) -> Result<Self, Error> {
         Ok(Self { _f: PhantomData })
     }
+
     fn state_len(&self) -> usize {
-        5
+        State::<F>::state_number()
     }
+
     fn external_inputs_len(&self) -> usize {
         0
     }
@@ -82,16 +84,21 @@ impl<F: PrimeField> FCircuit<F> for MultiInputsFCircuit<F> {
         z_i: Vec<FpVar<F>>,
         _external_inputs: Vec<FpVar<F>>,
     ) -> Result<Vec<FpVar<F>>, SynthesisError> {
+        let cs_state = State::cs_state(z_i.clone());
+
         let four = FpVar::<F>::new_constant(cs.clone(), F::from(4u32))?;
         let forty = FpVar::<F>::new_constant(cs.clone(), F::from(40u32))?;
         let onehundred = FpVar::<F>::new_constant(cs.clone(), F::from(100u32))?;
-        let a = z_i[0].clone() + four.clone();
-        let b = z_i[1].clone() + forty.clone();
-        let c = z_i[2].clone() * four;
-        let d = z_i[3].clone() * forty;
-        let e = z_i[4].clone() + onehundred;
 
-        Ok(vec![a, b, c, d, e])
+        let next_cs_state = StateConstraint {
+            a: cs_state.a.clone() + four.clone(),
+            b: cs_state.b.clone() + forty.clone(),
+            c: cs_state.c.clone() * four,
+            d: cs_state.d.clone() * forty,
+            e: cs_state.e.clone() + onehundred,
+        };
+
+        Ok(Vec::from(next_cs_state))
     }
 }
 
diff --git a/frontend-macro/Cargo.toml b/frontend-macro/Cargo.toml
index 8d03a1a56..a9a50f7b1 100644
--- a/frontend-macro/Cargo.toml
+++ b/frontend-macro/Cargo.toml
@@ -11,7 +11,7 @@ quote = "0.6"
 proc-macro2 = "0.4"
 ark-ff = "^0.4.0"
 ark-bn254 = {version="0.4.0", features=["r1cs"]}
-
+ark-r1cs-std = { version = "0.4.0", default-features = false } # this is patched at the workspace level
 
 [dev-dependencies]
 trybuild = "1.0"
diff --git a/frontend-macro/src/lib.rs b/frontend-macro/src/lib.rs
index dc9a4b73f..e320aff0f 100644
--- a/frontend-macro/src/lib.rs
+++ b/frontend-macro/src/lib.rs
@@ -7,7 +7,9 @@ use syn::{parse_macro_input, DeriveInput};
 pub fn derive(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
     let iden = &ast.ident;
-
+    let cs_iden_name = format!("{}Constraint", iden.to_string());
+    let cs_iden = syn::Ident::new( &cs_iden_name, iden.span());
+    
     let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
     
     let fields = if let syn::Data::Struct(syn::DataStruct {
@@ -21,11 +23,26 @@ pub fn derive(input: TokenStream) -> TokenStream {
     };
 
     
+    let cs_fields_to_vec = fields.iter().map(|f| {
+        let name = &f.ident;
+        quote! { value.#name }
+    });
+
+    let cs_fields = fields.iter().map(|f| {
+        let name = &f.ident;
+        quote! {pub #name: ark_r1cs_std::fields::fp::FpVar<F> }
+    });
+
     let builder_fields = fields.iter().map(|f| {
         let name = &f.ident;
         quote! { value.#name }
     });
 
+    let cs_vec_to_fields = fields.iter().enumerate().map(|(id, f)| {
+        let name = &f.ident;
+        quote! {#name: vec[#id].clone()}
+    });
+    
     let vec_to_fields = fields.iter().enumerate().map(|(id, f)| {
         let name = &f.ident;
         quote! {#name: vec[#id]}
@@ -33,8 +50,7 @@ pub fn derive(input: TokenStream) -> TokenStream {
 
     let state_number = fields.len();
 
-    let expanded = quote! {
-        
+    let another = quote! {
         impl #impl_generics #iden #ty_generics #where_clause {
             pub fn state_number() -> usize {
                 #state_number
@@ -56,6 +72,37 @@ pub fn derive(input: TokenStream) -> TokenStream {
             }
         }
     };
+
+    let expanded = quote! {
+        
+        #another
+
+        pub struct #cs_iden<F: ark_ff::PrimeField> {
+            #(#cs_fields,)*
+        }
+
+
+        impl<F: PrimeField> From<Vec<ark_r1cs_std::fields::fp::FpVar<F>>> for #cs_iden<F> {
+            fn from(vec: Vec<ark_r1cs_std::fields::fp::FpVar<F>>) -> #cs_iden<F>{
+                #cs_iden {
+                    #(#cs_vec_to_fields,)*
+                }     
+            }
+        }
+
+        impl<F: PrimeField> From<#cs_iden<F>> for Vec<ark_r1cs_std::fields::fp::FpVar<F>> {
+            fn from(value: #cs_iden<F>) -> Vec<ark_r1cs_std::fields::fp::FpVar<F>> {
+                vec![#(#cs_fields_to_vec,)*] 
+            }
+        }
+
+
+        impl<F: ark_ff::PrimeField> #iden<F>{
+            pub fn cs_state(v: Vec< ark_r1cs_std::fields::fp::FpVar<F>>) -> #cs_iden<F> {
+                #cs_iden::from(v)
+            }
+        }
+    };
     expanded.into()
 }
 
diff --git a/frontend-macro/src/main.rs b/frontend-macro/src/main.rs
index 9f881cde5..8ab044760 100644
--- a/frontend-macro/src/main.rs
+++ b/frontend-macro/src/main.rs
@@ -1,7 +1,6 @@
 use ark_bn254::Fr;
 use ark_ff::PrimeField;
 use frontend_macro::Flatten;
-
 #[derive(Flatten, Debug)]
 struct State<F: PrimeField> {
     a: F,
diff --git a/frontend-macro/tests/parse.rs b/frontend-macro/tests/parse.rs
index 5b07f1ea4..8ab044760 100644
--- a/frontend-macro/tests/parse.rs
+++ b/frontend-macro/tests/parse.rs
@@ -1,11 +1,21 @@
+use ark_bn254::Fr;
 use ark_ff::PrimeField;
 use frontend_macro::Flatten;
-
-#[derive(Flatten)]
+#[derive(Flatten, Debug)]
 struct State<F: PrimeField> {
-    a: F
+    a: F,
+    b: F
 }
 
 fn main() {
+    let s = State::<Fr> {
+        a: Fr::from(1u32),
+        b: Fr::from(1u32)
+    };
+
+    let v: Vec<Fr> = Vec::from(s);
 
+    println!("{:?}", State::<Fr>::state_number());
+    println!("{:?}", v);
+    println!("{:?}", State::from(v));
 }
\ No newline at end of file

From 32d806cae364d007bf3ea4a209cdbc9726e9b0ca Mon Sep 17 00:00:00 2001
From: Vu Vo <vu.voth@gmail.com>
Date: Mon, 13 May 2024 22:47:42 +0700
Subject: [PATCH 4/6] default external inputs len is zero

---
 folding-schemes/src/frontend/mod.rs |  5 ++++-
 frontend-macro/src/lib.rs           |  4 +++-
 frontend-macro/src/main.rs          | 21 ---------------------
 3 files changed, 7 insertions(+), 23 deletions(-)
 delete mode 100644 frontend-macro/src/main.rs

diff --git a/folding-schemes/src/frontend/mod.rs b/folding-schemes/src/frontend/mod.rs
index 59f18eb16..2ae3b5a33 100644
--- a/folding-schemes/src/frontend/mod.rs
+++ b/folding-schemes/src/frontend/mod.rs
@@ -22,7 +22,10 @@ pub trait FCircuit<F: PrimeField>: Clone + Debug {
 
     /// returns the number of elements in the external inputs used by the FCircuit. External inputs
     /// are optional, and in case no external inputs are used, this method should return 0.
-    fn external_inputs_len(&self) -> usize;
+    /// default is zero 
+    fn external_inputs_len(&self) -> usize {
+        0
+    }
 
     /// computes the next state values in place, assigning z_{i+1} into z_i, and computing the new
     /// z_{i+1}
diff --git a/frontend-macro/src/lib.rs b/frontend-macro/src/lib.rs
index e320aff0f..1e4af9a95 100644
--- a/frontend-macro/src/lib.rs
+++ b/frontend-macro/src/lib.rs
@@ -7,7 +7,7 @@ use syn::{parse_macro_input, DeriveInput};
 pub fn derive(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
     let iden = &ast.ident;
-    let cs_iden_name = format!("{}Constraint", iden.to_string());
+    let cs_iden_name = format!("{}Constraint", iden);
     let cs_iden = syn::Ident::new( &cs_iden_name, iden.span());
     
     let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
@@ -103,6 +103,8 @@ pub fn derive(input: TokenStream) -> TokenStream {
             }
         }
     };
+
+    
     expanded.into()
 }
 
diff --git a/frontend-macro/src/main.rs b/frontend-macro/src/main.rs
deleted file mode 100644
index 8ab044760..000000000
--- a/frontend-macro/src/main.rs
+++ /dev/null
@@ -1,21 +0,0 @@
-use ark_bn254::Fr;
-use ark_ff::PrimeField;
-use frontend_macro::Flatten;
-#[derive(Flatten, Debug)]
-struct State<F: PrimeField> {
-    a: F,
-    b: F
-}
-
-fn main() {
-    let s = State::<Fr> {
-        a: Fr::from(1u32),
-        b: Fr::from(1u32)
-    };
-
-    let v: Vec<Fr> = Vec::from(s);
-
-    println!("{:?}", State::<Fr>::state_number());
-    println!("{:?}", v);
-    println!("{:?}", State::from(v));
-}
\ No newline at end of file

From 7ea095039d16d2aafb188639a6e1b7dffb722fb6 Mon Sep 17 00:00:00 2001
From: Vu Vo <vu.voth@gmail.com>
Date: Mon, 13 May 2024 23:50:58 +0700
Subject: [PATCH 5/6] refactor code

---
 frontend-macro/src/lib.rs | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/frontend-macro/src/lib.rs b/frontend-macro/src/lib.rs
index 1e4af9a95..ec983f5fb 100644
--- a/frontend-macro/src/lib.rs
+++ b/frontend-macro/src/lib.rs
@@ -50,7 +50,7 @@ pub fn derive(input: TokenStream) -> TokenStream {
 
     let state_number = fields.len();
 
-    let another = quote! {
+    let state_macro = quote! {
         impl #impl_generics #iden #ty_generics #where_clause {
             pub fn state_number() -> usize {
                 #state_number
@@ -73,10 +73,7 @@ pub fn derive(input: TokenStream) -> TokenStream {
         }
     };
 
-    let expanded = quote! {
-        
-        #another
-
+    let constraint_macro = quote! {
         pub struct #cs_iden<F: ark_ff::PrimeField> {
             #(#cs_fields,)*
         }
@@ -104,7 +101,13 @@ pub fn derive(input: TokenStream) -> TokenStream {
         }
     };
 
-    
+    let expanded = quote! {        
+        #state_macro
+
+        #constraint_macro
+    };
+
+
     expanded.into()
 }
 

From e887b25e53a1b8059c1f781cb85253d0bc707827 Mon Sep 17 00:00:00 2001
From: Vu Vo <vu.voth@gmail.com>
Date: Sat, 25 May 2024 09:28:22 +0700
Subject: [PATCH 6/6] apply review suggestions

---
 folding-schemes/Cargo.toml          |  2 +-
 folding-schemes/src/frontend/mod.rs |  2 +-
 frontend-macro/Cargo.toml           |  5 +++--
 frontend-macro/src/lib.rs           | 21 +++++++----------
 frontend-macro/tests/parse.rs       |  6 ++---
 frontend-macro/tests/runner.rs      | 35 +++++++++++++++++++++++++----
 6 files changed, 47 insertions(+), 24 deletions(-)

diff --git a/folding-schemes/Cargo.toml b/folding-schemes/Cargo.toml
index 678aff433..65766190a 100644
--- a/folding-schemes/Cargo.toml
+++ b/folding-schemes/Cargo.toml
@@ -22,7 +22,6 @@ num-integer = "0.1"
 color-eyre = "=0.6.2"
 ark-bn254 = {version="0.4.0"}
 ark-groth16 = { version = "^0.4.0" }
-frontend-macro = { path = "../frontend-macro/"}
 
 # tmp imports for espresso's sumcheck
 espresso_subroutines = {git="https://github.com/EspressoSystems/hyperplonk", package="subroutines"}
@@ -35,6 +34,7 @@ ark-grumpkin = {version="0.4.0", features=["r1cs"]}
 rand = "0.8.5"
 tracing = { version = "0.1", default-features = false, features = [ "attributes" ] }
 tracing-subscriber = { version = "0.2" }
+frontend-macro = { path = "../frontend-macro/"}
 
 [features]
 default = ["parallel"]
diff --git a/folding-schemes/src/frontend/mod.rs b/folding-schemes/src/frontend/mod.rs
index 2ae3b5a33..ab85e69a3 100644
--- a/folding-schemes/src/frontend/mod.rs
+++ b/folding-schemes/src/frontend/mod.rs
@@ -22,7 +22,7 @@ pub trait FCircuit<F: PrimeField>: Clone + Debug {
 
     /// returns the number of elements in the external inputs used by the FCircuit. External inputs
     /// are optional, and in case no external inputs are used, this method should return 0.
-    /// default is zero 
+    /// default is zero
     fn external_inputs_len(&self) -> usize {
         0
     }
diff --git a/frontend-macro/Cargo.toml b/frontend-macro/Cargo.toml
index a9a50f7b1..17c0fbe7e 100644
--- a/frontend-macro/Cargo.toml
+++ b/frontend-macro/Cargo.toml
@@ -9,12 +9,13 @@ edition = "2021"
 syn = { version = "0.15", features = ["extra-traits"] }
 quote = "0.6"
 proc-macro2 = "0.4"
+
+[dev-dependencies]
+trybuild = "1.0"
 ark-ff = "^0.4.0"
 ark-bn254 = {version="0.4.0", features=["r1cs"]}
 ark-r1cs-std = { version = "0.4.0", default-features = false } # this is patched at the workspace level
 
-[dev-dependencies]
-trybuild = "1.0"
 
 [lib]
 proc-macro = true
\ No newline at end of file
diff --git a/frontend-macro/src/lib.rs b/frontend-macro/src/lib.rs
index ec983f5fb..36a17b08d 100644
--- a/frontend-macro/src/lib.rs
+++ b/frontend-macro/src/lib.rs
@@ -2,16 +2,15 @@ use proc_macro::TokenStream;
 use quote::quote;
 use syn::{parse_macro_input, DeriveInput};
 
-
 #[proc_macro_derive(Flatten)]
 pub fn derive(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
     let iden = &ast.ident;
     let cs_iden_name = format!("{}Constraint", iden);
-    let cs_iden = syn::Ident::new( &cs_iden_name, iden.span());
-    
+    let cs_iden = syn::Ident::new(&cs_iden_name, iden.span());
+
     let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
-    
+
     let fields = if let syn::Data::Struct(syn::DataStruct {
         fields: syn::Fields::Named(syn::FieldsNamed { ref named, .. }),
         ..
@@ -22,7 +21,6 @@ pub fn derive(input: TokenStream) -> TokenStream {
         unimplemented!();
     };
 
-    
     let cs_fields_to_vec = fields.iter().map(|f| {
         let name = &f.ident;
         quote! { value.#name }
@@ -42,7 +40,7 @@ pub fn derive(input: TokenStream) -> TokenStream {
         let name = &f.ident;
         quote! {#name: vec[#id].clone()}
     });
-    
+
     let vec_to_fields = fields.iter().enumerate().map(|(id, f)| {
         let name = &f.ident;
         quote! {#name: vec[#id]}
@@ -68,7 +66,7 @@ pub fn derive(input: TokenStream) -> TokenStream {
                 assert!(vec.len() == #iden::#ty_generics::state_number());
                 #iden {
                     #(#vec_to_fields,)*
-                }               
+                }
             }
         }
     };
@@ -83,13 +81,13 @@ pub fn derive(input: TokenStream) -> TokenStream {
             fn from(vec: Vec<ark_r1cs_std::fields::fp::FpVar<F>>) -> #cs_iden<F>{
                 #cs_iden {
                     #(#cs_vec_to_fields,)*
-                }     
+                }
             }
         }
 
         impl<F: PrimeField> From<#cs_iden<F>> for Vec<ark_r1cs_std::fields::fp::FpVar<F>> {
             fn from(value: #cs_iden<F>) -> Vec<ark_r1cs_std::fields::fp::FpVar<F>> {
-                vec![#(#cs_fields_to_vec,)*] 
+                vec![#(#cs_fields_to_vec,)*]
             }
         }
 
@@ -101,14 +99,11 @@ pub fn derive(input: TokenStream) -> TokenStream {
         }
     };
 
-    let expanded = quote! {        
+    let expanded = quote! {
         #state_macro
 
         #constraint_macro
     };
 
-
     expanded.into()
 }
-
-
diff --git a/frontend-macro/tests/parse.rs b/frontend-macro/tests/parse.rs
index 8ab044760..665a4d7b1 100644
--- a/frontend-macro/tests/parse.rs
+++ b/frontend-macro/tests/parse.rs
@@ -4,13 +4,13 @@ use frontend_macro::Flatten;
 #[derive(Flatten, Debug)]
 struct State<F: PrimeField> {
     a: F,
-    b: F
+    b: F,
 }
 
 fn main() {
     let s = State::<Fr> {
         a: Fr::from(1u32),
-        b: Fr::from(1u32)
+        b: Fr::from(1u32),
     };
 
     let v: Vec<Fr> = Vec::from(s);
@@ -18,4 +18,4 @@ fn main() {
     println!("{:?}", State::<Fr>::state_number());
     println!("{:?}", v);
     println!("{:?}", State::from(v));
-}
\ No newline at end of file
+}
diff --git a/frontend-macro/tests/runner.rs b/frontend-macro/tests/runner.rs
index 26917f3fe..b12fe9608 100644
--- a/frontend-macro/tests/runner.rs
+++ b/frontend-macro/tests/runner.rs
@@ -1,5 +1,32 @@
-#[test]
-fn tests() {
-    let t = trybuild::TestCases::new();
-    t.pass("tests/parse.rs");
+#[cfg(test)]
+mod test {
+
+    #[test]
+    fn try_compile() {
+        let t = trybuild::TestCases::new();
+        t.pass("tests/parse.rs");
+    }
+
+    #[test]
+    fn try_run_test() {
+        use ark_bn254::Fr;
+        use ark_ff::PrimeField;
+        use frontend_macro::Flatten;
+        #[derive(Flatten, Debug, PartialEq, Clone)]
+        struct State<F: PrimeField> {
+            a: F,
+            b: F,
+        }
+
+        let s = State::<Fr> {
+            a: Fr::from(1u32),
+            b: Fr::from(1u32),
+        };
+
+        let v: Vec<Fr> = Vec::from(s.clone());
+
+        assert_eq!(2, State::<Fr>::state_number());
+        assert_eq!(vec![s.a, s.b], v);
+        assert_eq!(s, State::from(v));
+    }
 }