bring repo up-to-date (#1)

* bring repo up-to-date

* ignore doctest

Author: fbielejec

Cargo.lock

@@ -14,12 +14,15 @@ repository = "https://github.com/Cardinal-Cryptography/zkOS"
 [workspace.dependencies]
 console_error_panic_hook = { version = "0.1.7" }
 criterion = { version = "0.5.1" }
+darling = { version = "0.20.10" }
 getrandom = { version = "0.2" }
 halo2_poseidon = { git = "ssh://git@github.com/Cardinal-Cryptography/poseidon-gadget", branch = "poseidon2-pow7" }
 halo2_proofs = { git = "https://github.com/privacy-scaling-explorations/halo2", tag = "v0.3.0", default-features = false }
 human_bytes = { version = "0.4.3", default-features = false }
 itertools = { version = "0.13.0" }
 once_cell = { version = "1.20.2" }
+proc-macro2 = { version = "1.0.86" }
+quote = { version = "1.0.37" }
 rand = { version = "0.8.5" }
 rand_chacha = { version = "0.3.1" }
 rand_core = { version = "0.6.4" }
@@ -30,8 +33,10 @@ sha3 = { version = "0.10" }
 static_assertions = { version = "1.1.0" }
 strum = { version = "0.26.3" }
 strum_macros = { version = "0.26.3" }
+syn = { version = "2.0.79" }
 thiserror = { version = "1.0.61" }
 
 # Local dependencies
+macros = { path = "crates/macros" }
 shielder-circuits = { path = "crates/shielder-circuits" }
 transcript = { path = "crates/transcript" }

Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "macros"
+version = "0.1.0"
+description = "Procedural macros for zkOS crates"
+
+edition.workspace = true
+authors.workspace = true
+homepage.workspace = true
+license.workspace = true
+categories.workspace = true
+repository.workspace = true
+
+[lib]
+doctest = false
+proc-macro = true
+
+[dependencies]
+darling = { workspace = true }
+proc-macro2 = { workspace = true }
+quote = { workspace = true }
+syn = { workspace = true, features = ["full"] }

crates/macros/Cargo.toml

@@ -0,0 +1,58 @@
+use darling::{ast::NestedMeta, FromMeta};
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::ItemStruct;
+
+type SynResult<T> = Result<T, syn::Error>;
+
+#[derive(Debug, FromMeta)]
+struct Attributes {
+    field_type: Option<syn::Path>,
+    receiver: syn::Type,
+    impl_generics: String,
+    embedded: syn::Type,
+}
+
+/// Auxiliary function to enter ?-based error propagation.
+pub fn embeddable(attr: TokenStream2, item: TokenStream2) -> SynResult<TokenStream2> {
+    let item_struct = syn::parse2::<ItemStruct>(item)?;
+    let backed_up_struct = item_struct.clone();
+
+    let Attributes {
+        field_type,
+        receiver,
+        impl_generics,
+        embedded,
+    } = Attributes::from_list(&NestedMeta::parse_meta_list(attr)?)?;
+    let field_type = field_type.unwrap_or_else(|| syn::parse_quote!(F));
+    let impl_generics = syn::parse_str::<syn::Generics>(&impl_generics)?;
+
+    let struct_name = item_struct.ident;
+
+    let field_embedding = item_struct.fields.iter().map(|field| {
+        let field_name = &field.ident.clone().expect("Only named fields are supported");
+        quote! {
+            #field_name: self.#field_name.embed(&mut layouter, advice_pool, stringify!(#field_name))?
+        }
+    });
+
+    Ok(quote! {
+        #backed_up_struct
+
+        impl #impl_generics Embed < #field_type > for #receiver {
+            type Embedded = #embedded;
+
+            fn embed(
+                &self,
+                layouter: &mut impl halo2_proofs::circuit::Layouter< #field_type >,
+                advice_pool: &crate::column_pool::ColumnPool<halo2_proofs::plonk::Advice>,
+                annotation: impl Into<alloc::string::String>,
+            ) -> Result<Self::Embedded, halo2_proofs::plonk::Error> {
+                let mut layouter = layouter.namespace(|| annotation);
+                Ok(#struct_name {
+                    #(#field_embedding),*
+                })
+            }
+        }
+    })
+}

crates/macros/src/embed.rs

@@ -0,0 +1,64 @@
+use proc_macro::TokenStream;
+
+mod embed;
+
+/// Derive the `Embed` trait for a struct.
+///
+/// # Requirements
+///
+/// 1. All the fields of the struct already implement `Embed`.
+/// 2. Only structs with named fields are supported
+/// 3. `halo2_proofs` must be in scope.
+/// 4. Can be used only in the `shielder_circuits` crate.
+///
+/// # Attributes
+///
+/// - `field_type`: The type of the field that will be used in the `Embed` trait implementation.
+///    If not provided, `F` is used.
+/// - `receiver`: The type of the struct that will implement the `Embed` trait.
+/// - `impl_generics`: Generics that will be used in the `Embed` trait implementation.
+/// - `embedded`: The type that the struct will be embedded into.
+///
+/// # Example
+///
+/// ```no_run
+/// use crate::embeddable;
+///
+/// #[embeddable(
+///     receiver = "IntermediateValues<Value<F>>",
+///     impl_generics = "<F: FieldExt>",
+///     embedded = "IntermediateValues<crate::AssignedCell<F>>"
+/// )]
+/// pub struct IntermediateValues<F> {
+///     /// Account balance after the deposit is made.
+///     pub account_new_balance: F,
+/// }
+/// ```
+///
+/// This will generate the following code:
+///
+/// ```rust, no_run
+/// impl<F: FieldExt> Embed<F> for IntermediateValues<Value<F>> {
+///     type Embedded = IntermediateValues<crate::AssignedCell<F>>;
+///     fn embed(
+///         &self,
+///         layouter: &mut impl halo2_proofs::circuit::Layouter<F>,
+///         advice_pool: &crate::column_pool::ColumnPool<halo2_proofs::plonk::Advice>,
+///         annotation: impl Into<alloc::string::String>,
+///     ) -> Result<Self::Embedded, halo2_proofs::plonk::Error> {
+///         let mut layouter = layouter.namespace(|| annotation);
+///         Ok(IntermediateValues {
+///             account_new_balance: self
+///                 .account_new_balance
+///                 .embed(&mut layouter, advice_pool, "account_new_balance")?,
+///         })
+///     }
+/// }
+/// ```
+#[proc_macro_attribute]
+pub fn embeddable(attr: TokenStream, item: TokenStream) -> TokenStream {
+    match embed::embeddable(attr.into(), item.into()) {
+        Ok(ts) => ts.into(),
+        Err(e) => e.to_compile_error().into(),
+    }
+}

crates/macros/src/lib.rs

@@ -17,6 +17,7 @@ getrandom = { workspace = true, optional = true }
 halo2_poseidon = { workspace = true }
 halo2_proofs = { workspace = true }
 human_bytes = { workspace = true }
+macros = { workspace = true }
 once_cell = { workspace = true }
 rand = { workspace = true, features = ["small_rng"] }
 rand_chacha = { workspace = true }

crates/shielder-circuits/Cargo.toml

@@ -10,14 +10,11 @@ use crate::{
 #[derive(Clone, Debug)]
 pub struct IdHidingChip<F: FieldExt, const CHUNK_SIZE: usize> {
     pub poseidon: PoseidonChip<F>,
-    pub range_check: LookupRangeCheckChip<F, CHUNK_SIZE>,
+    pub range_check: LookupRangeCheckChip<CHUNK_SIZE>,
 }
 
 impl<F: FieldExt, const CHUNK_SIZE: usize> IdHidingChip<F, CHUNK_SIZE> {
-    pub fn new(
-        poseidon: PoseidonChip<F>,
-        range_check: LookupRangeCheckChip<F, CHUNK_SIZE>,
-    ) -> Self {
+    pub fn new(poseidon: PoseidonChip<F>, range_check: LookupRangeCheckChip<CHUNK_SIZE>) -> Self {
         Self {
             poseidon,
             range_check,