Gate artifact embedding behind feature flags.

rust/logos-blockchain-circuits-common/src/artifacts.rs

@@ -6,14 +6,23 @@
 ///
 /// # Generated items
 ///
-/// | Item                    | Description                             |
-/// |-------------------------|-----------------------------------------|
-/// | `PROVING_KEY_PATH`      | Path to the proving key (`.zkey`)       |
-/// | `PROVING_KEY`           | Proving key bytes                       |
-/// | `VERIFICATION_KEY_PATH` | Path to the verification key (`.json`)  |
-/// | `VERIFICATION_KEY`      | Verification key bytes                  |
-/// | `CIRCUIT_DAT_PATH`      | Path to the witness generator data      |
-/// | `CIRCUIT_DAT`           | Witness generator data bytes            |
+/// | Item                    | Description                                               |
+/// |-------------------------|-----------------------------------------------------------|
+/// | `PROVING_KEY_PATH`      | Path to the proving key (`.zkey`)                         |
+/// | `PROVING_KEY`           | Proving key bytes (`embed-proving-key` flag)              |
+/// | `VERIFICATION_KEY_PATH` | Path to the verification key (`.json`)                    |
+/// | `VERIFICATION_KEY`      | Verification key bytes (`embed-verification-key` flag)    |
+/// | `CIRCUIT_PATH`          | Path to the witness generator data                        |
+/// | `CIRCUIT`               | Witness generator data bytes (`embed-circuit` flag)       |
+///
+/// The path constants are always available. Each byte static requires its
+/// own feature flag in the calling crate.
+///
+/// # Feature flag placement
+///
+/// The required feature flags must be declared in the calling crate's
+/// `[features]` section. `#[cfg(feature = "...")]` inside a `macro_rules!` body
+/// is evaluated in the calling crate's context, not this crate's.
 ///
 /// # Example
 ///
@@ -33,15 +42,17 @@ macro_rules! circuit_artifacts {
             }
 
             pub const PROVING_KEY_PATH: &str = __circuit_file!("proving_key.zkey");
+            #[cfg(feature = "embed-proving-key")]
             pub static PROVING_KEY: &[u8] = include_bytes!(__circuit_file!("proving_key.zkey"));
 
             pub const VERIFICATION_KEY_PATH: &str = __circuit_file!("verification_key.json");
+            #[cfg(feature = "embed-verification-key")]
             pub static VERIFICATION_KEY: &[u8] =
                 include_bytes!(__circuit_file!("verification_key.json"));
 
-            pub const CIRCUIT_DAT_PATH: &str = __circuit_file!("witness_generator.dat");
-            pub static CIRCUIT_DAT: &[u8] =
-                include_bytes!(__circuit_file!("witness_generator.dat"));
+            pub const CIRCUIT_PATH: &str = __circuit_file!("witness_generator.dat");
+            #[cfg(feature = "embed-circuit")]
+            pub static CIRCUIT: &[u8] = include_bytes!(__circuit_file!("witness_generator.dat"));
         }
     };
 }

rust/logos-blockchain-circuits-poc-sys/Cargo.toml

@@ -10,7 +10,10 @@ repository.workspace = true
 version.workspace = true
 
 [features]
-default = ["prebuilt"]
+default = ["embed-circuit", "prebuilt"]
+embed-circuit = []
+embed-proving-key = []
+embed-verification-key = []
 prebuilt = ["lbc-build/prebuilt"]
 
 [lints]

rust/logos-blockchain-circuits-poc-sys/src/lib.rs

@@ -1,4 +1,6 @@
 mod ffi;
 pub mod native;
 
-pub use native::{PocWitnessInput, artifacts, generate_witness, generate_witness_from_files};
+#[cfg(feature = "embed-circuit")]
+pub use native::embedded::{PocWitnessInput, generate_witness};
+pub use native::{artifacts, generate_witness_from_files};

rust/logos-blockchain-circuits-poc-sys/src/native.rs

@@ -1,34 +1,41 @@
 use std::path::Path;
 
 use lbc_common::string::path_as_null_terminated_string;
-use lbc_types::{
-    ffi,
-    native::{Error, Witness},
-};
+use lbc_types::native::Error;
 
-use crate::ffi::{poc_generate_witness, poc_generate_witness_from_files};
+use crate::ffi::poc_generate_witness_from_files;
 
 lbc_common::circuit_artifacts!("poc");
 
-pub struct PocDat;
-impl<'dat> lbc_types::CircuitDat<'dat> for PocDat {
-    const DAT: &'dat [u8] = artifacts::CIRCUIT_DAT;
-}
+#[cfg(feature = "embed-circuit")]
+pub mod embedded {
+    use lbc_types::{
+        ffi,
+        native::{Circuit, CircuitWitnessInput, Error, Witness},
+    };
 
-pub type PocWitnessInput<'dat> = lbc_types::CircuitWitnessInput<'dat, PocDat>;
+    use crate::ffi::poc_generate_witness;
 
-pub fn generate_witness(input: &PocWitnessInput) -> Result<Witness, Error> {
-    let ffi_input_guard = input.as_ffi();
-    let ffi_input = ffi_input_guard.as_ref();
+    pub struct PocCircuit;
+    impl<'dat> Circuit<'dat> for PocCircuit {
+        const DAT: &'dat [u8] = super::artifacts::CIRCUIT;
+    }
+    pub type PocWitnessInput<'dat> = CircuitWitnessInput<'dat, PocCircuit>;
 
-    let mut ffi_output_bytes = ffi::Bytes::null();
+    pub fn generate_witness(input: &PocWitnessInput) -> Result<Witness, Error> {
+        let ffi_input_guard = input.as_ffi();
+        let ffi_input = ffi_input_guard.as_ref();
 
-    // SAFETY: ffi_input is a valid pointer and ffi_output_bytes is a locally
-    // initialized null Bytes.
-    let status =
-        unsafe { poc_generate_witness(std::ptr::from_ref(ffi_input), &raw mut ffi_output_bytes) };
+        let mut ffi_output_bytes = ffi::Bytes::null();
 
-    status.try_into().map(|()| Witness::from(ffi_output_bytes))
+        // SAFETY: ffi_input is a valid pointer and ffi_output_bytes is a locally
+        // initialized null Bytes.
+        let status = unsafe {
+            poc_generate_witness(std::ptr::from_ref(ffi_input), &raw mut ffi_output_bytes)
+        };
+
+        status.try_into().map(|()| Witness::from(ffi_output_bytes))
+    }
 }
 
 pub fn generate_witness_from_files(dat: &Path, inputs: &Path, output: &Path) -> Result<(), Error> {
@@ -42,11 +49,14 @@ pub fn generate_witness_from_files(dat: &Path, inputs: &Path, output: &Path) ->
         .try_into()
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "embed-circuit"))]
 mod tests {
     use std::{path::PathBuf, sync::LazyLock};
 
-    use super::{PocWitnessInput, generate_witness, generate_witness_from_files};
+    use super::{
+        embedded::{PocWitnessInput, generate_witness},
+        generate_witness_from_files,
+    };
 
     static LIB_DIR: LazyLock<PathBuf> =
         LazyLock::new(|| PathBuf::from(env!("LBC_ROOT_DIR")).join("poc"));

rust/logos-blockchain-circuits-pol-sys/Cargo.toml

@@ -10,7 +10,10 @@ repository.workspace = true
 version.workspace = true
 
 [features]
-default = ["prebuilt"]
+default = ["embed-circuit", "prebuilt"]
+embed-circuit = []
+embed-proving-key = []
+embed-verification-key = []
 prebuilt = ["lbc-build/prebuilt"]
 
 [lints]

rust/logos-blockchain-circuits-pol-sys/src/lib.rs

@@ -1,4 +1,6 @@
 mod ffi;
 pub mod native;
 
-pub use native::{PolWitnessInput, artifacts, generate_witness, generate_witness_from_files};
+#[cfg(feature = "embed-circuit")]
+pub use native::embedded::{PolWitnessInput, generate_witness};
+pub use native::{artifacts, generate_witness_from_files};

rust/logos-blockchain-circuits-pol-sys/src/native.rs

@@ -1,34 +1,41 @@
 use std::path::Path;
 
 use lbc_common::string::path_as_null_terminated_string;
-use lbc_types::{
-    ffi,
-    native::{Error, Witness},
-};
+use lbc_types::native::Error;
 
-use crate::ffi::{pol_generate_witness, pol_generate_witness_from_files};
+use crate::ffi::pol_generate_witness_from_files;
 
 lbc_common::circuit_artifacts!("pol");
 
-pub struct PolDat;
-impl<'dat> lbc_types::CircuitDat<'dat> for PolDat {
-    const DAT: &'dat [u8] = artifacts::CIRCUIT_DAT;
-}
+#[cfg(feature = "embed-circuit")]
+pub mod embedded {
+    use lbc_types::{
+        ffi,
+        native::{Circuit, CircuitWitnessInput, Error, Witness},
+    };
 
-pub type PolWitnessInput<'dat> = lbc_types::CircuitWitnessInput<'dat, PolDat>;
+    use crate::ffi::pol_generate_witness;
 
-pub fn generate_witness(input: &PolWitnessInput) -> Result<Witness, Error> {
-    let ffi_input_guard = input.as_ffi();
-    let ffi_input = ffi_input_guard.as_ref();
+    pub struct PolCircuit;
+    impl<'dat> Circuit<'dat> for PolCircuit {
+        const DAT: &'dat [u8] = super::artifacts::CIRCUIT;
+    }
+    pub type PolWitnessInput<'dat> = CircuitWitnessInput<'dat, PolCircuit>;
 
-    let mut ffi_output_bytes = ffi::Bytes::null();
+    pub fn generate_witness(input: &PolWitnessInput) -> Result<Witness, Error> {
+        let ffi_input_guard = input.as_ffi();
+        let ffi_input = ffi_input_guard.as_ref();
 
-    // SAFETY: ffi_input is a valid pointer and ffi_output_bytes is a locally
-    // initialized null Bytes.
-    let status =
-        unsafe { pol_generate_witness(std::ptr::from_ref(ffi_input), &raw mut ffi_output_bytes) };
+        let mut ffi_output_bytes = ffi::Bytes::null();
 
-    status.try_into().map(|()| Witness::from(ffi_output_bytes))
+        // SAFETY: ffi_input is a valid pointer and ffi_output_bytes is a locally
+        // initialized null Bytes.
+        let status = unsafe {
+            pol_generate_witness(std::ptr::from_ref(ffi_input), &raw mut ffi_output_bytes)
+        };
+
+        status.try_into().map(|()| Witness::from(ffi_output_bytes))
+    }
 }
 
 pub fn generate_witness_from_files(dat: &Path, inputs: &Path, output: &Path) -> Result<(), Error> {
@@ -42,11 +49,14 @@ pub fn generate_witness_from_files(dat: &Path, inputs: &Path, output: &Path) ->
         .try_into()
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "embed-circuit"))]
 mod tests {
     use std::{path::PathBuf, sync::LazyLock};
 
-    use super::{PolWitnessInput, generate_witness, generate_witness_from_files};
+    use super::{
+        embedded::{PolWitnessInput, generate_witness},
+        generate_witness_from_files,
+    };
 
     static LIB_DIR: LazyLock<PathBuf> =
         LazyLock::new(|| PathBuf::from(env!("LBC_ROOT_DIR")).join("pol"));

rust/logos-blockchain-circuits-poq-sys/Cargo.toml

@@ -10,7 +10,10 @@ repository.workspace = true
 version.workspace = true
 
 [features]
-default = ["prebuilt"]
+default = ["embed-circuit", "prebuilt"]
+embed-circuit = []
+embed-proving-key = []
+embed-verification-key = []
 prebuilt = ["lbc-build/prebuilt"]
 
 [lints]

rust/logos-blockchain-circuits-poq-sys/src/lib.rs

@@ -1,4 +1,6 @@
 mod ffi;
 pub mod native;
 
-pub use native::{PoqWitnessInput, artifacts, generate_witness, generate_witness_from_files};
+#[cfg(feature = "embed-circuit")]
+pub use native::embedded::{PoqWitnessInput, generate_witness};
+pub use native::{artifacts, generate_witness_from_files};

rust/logos-blockchain-circuits-poq-sys/src/native.rs

@@ -1,34 +1,41 @@
 use std::path::Path;
 
 use lbc_common::string::path_as_null_terminated_string;
-use lbc_types::{
-    ffi,
-    native::{Error, Witness},
-};
+use lbc_types::native::Error;
 
-use crate::ffi::{poq_generate_witness, poq_generate_witness_from_files};
+use crate::ffi::poq_generate_witness_from_files;
 
 lbc_common::circuit_artifacts!("poq");
 
-pub struct PoqDat;
-impl<'dat> lbc_types::CircuitDat<'dat> for PoqDat {
-    const DAT: &'dat [u8] = artifacts::CIRCUIT_DAT;
-}
+#[cfg(feature = "embed-circuit")]
+pub mod embedded {
+    use lbc_types::{
+        ffi,
+        native::{Circuit, CircuitWitnessInput, Error, Witness},
+    };
 
-pub type PoqWitnessInput<'dat> = lbc_types::CircuitWitnessInput<'dat, PoqDat>;
+    use crate::ffi::poq_generate_witness;
 
-pub fn generate_witness(input: &PoqWitnessInput) -> Result<Witness, Error> {
-    let ffi_input_guard = input.as_ffi();
-    let ffi_input = ffi_input_guard.as_ref();
+    pub struct PoqCircuit;
+    impl<'dat> Circuit<'dat> for PoqCircuit {
+        const DAT: &'dat [u8] = super::artifacts::CIRCUIT;
+    }
+    pub type PoqWitnessInput<'dat> = CircuitWitnessInput<'dat, PoqCircuit>;
 
-    let mut ffi_output_bytes = ffi::Bytes::null();
+    pub fn generate_witness(input: &PoqWitnessInput) -> Result<Witness, Error> {
+        let ffi_input_guard = input.as_ffi();
+        let ffi_input = ffi_input_guard.as_ref();
 
-    // SAFETY: ffi_input is a valid pointer and ffi_output_bytes is a locally
-    // initialized null Bytes.
-    let status =
-        unsafe { poq_generate_witness(std::ptr::from_ref(ffi_input), &raw mut ffi_output_bytes) };
+        let mut ffi_output_bytes = ffi::Bytes::null();
 
-    status.try_into().map(|()| Witness::from(ffi_output_bytes))
+        // SAFETY: ffi_input is a valid pointer and ffi_output_bytes is a locally
+        // initialized null Bytes.
+        let status = unsafe {
+            poq_generate_witness(std::ptr::from_ref(ffi_input), &raw mut ffi_output_bytes)
+        };
+
+        status.try_into().map(|()| Witness::from(ffi_output_bytes))
+    }
 }
 
 pub fn generate_witness_from_files(dat: &Path, inputs: &Path, output: &Path) -> Result<(), Error> {
@@ -42,11 +49,14 @@ pub fn generate_witness_from_files(dat: &Path, inputs: &Path, output: &Path) ->
         .try_into()
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "embed-circuit"))]
 mod tests {
     use std::{path::PathBuf, sync::LazyLock};
 
-    use super::{PoqWitnessInput, generate_witness, generate_witness_from_files};
+    use super::{
+        embedded::{PoqWitnessInput, generate_witness},
+        generate_witness_from_files,
+    };
 
     static LIB_DIR: LazyLock<PathBuf> =
         LazyLock::new(|| PathBuf::from(env!("LBC_ROOT_DIR")).join("poq"));

rust/logos-blockchain-circuits-signature-sys/Cargo.toml

@@ -10,7 +10,10 @@ repository.workspace = true
 version.workspace = true
 
 [features]
-default = ["prebuilt"]
+default = ["embed-circuit", "prebuilt"]
+embed-circuit = []
+embed-proving-key = []
+embed-verification-key = []
 prebuilt = ["lbc-build/prebuilt"]
 
 [lints]

rust/logos-blockchain-circuits-signature-sys/src/lib.rs

@@ -1,4 +1,6 @@
 mod ffi;
 pub mod native;
 
-pub use native::{SignatureWitnessInput, artifacts, generate_witness, generate_witness_from_files};
+#[cfg(feature = "embed-circuit")]
+pub use native::embedded::{SignatureWitnessInput, generate_witness};
+pub use native::{artifacts, generate_witness_from_files};

rust/logos-blockchain-circuits-signature-sys/src/native.rs

@@ -1,35 +1,41 @@
 use std::path::Path;
 
 use lbc_common::string::path_as_null_terminated_string;
-use lbc_types::{
-    ffi,
-    native::{Error, Witness},
-};
+use lbc_types::native::Error;
 
-use crate::ffi::{signature_generate_witness, signature_generate_witness_from_files};
+use crate::ffi::signature_generate_witness_from_files;
 
 lbc_common::circuit_artifacts!("signature");
 
-pub struct SignatureDat;
-impl<'dat> lbc_types::CircuitDat<'dat> for SignatureDat {
-    const DAT: &'dat [u8] = artifacts::CIRCUIT_DAT;
-}
-
-pub type SignatureWitnessInput<'dat> = lbc_types::CircuitWitnessInput<'dat, SignatureDat>;
-
-pub fn generate_witness(input: &SignatureWitnessInput) -> Result<Witness, Error> {
-    let ffi_input_guard = input.as_ffi();
-    let ffi_input = ffi_input_guard.as_ref();
-
-    let mut ffi_output_bytes = ffi::Bytes::null();
-
-    // SAFETY: ffi_input is a valid pointer and ffi_output_bytes is a locally
-    // initialized null Bytes.
-    let status = unsafe {
-        signature_generate_witness(std::ptr::from_ref(ffi_input), &raw mut ffi_output_bytes)
+#[cfg(feature = "embed-circuit")]
+pub mod embedded {
+    use lbc_types::{
+        ffi,
+        native::{Circuit, CircuitWitnessInput, Error, Witness},
     };
 
-    status.try_into().map(|()| Witness::from(ffi_output_bytes))
+    use crate::ffi::signature_generate_witness;
+
+    pub struct SignatureCircuit;
+    impl<'dat> Circuit<'dat> for SignatureCircuit {
+        const DAT: &'dat [u8] = super::artifacts::CIRCUIT;
+    }
+    pub type SignatureWitnessInput<'dat> = CircuitWitnessInput<'dat, SignatureCircuit>;
+
+    pub fn generate_witness(input: &SignatureWitnessInput) -> Result<Witness, Error> {
+        let ffi_input_guard = input.as_ffi();
+        let ffi_input = ffi_input_guard.as_ref();
+
+        let mut ffi_output_bytes = ffi::Bytes::null();
+
+        // SAFETY: ffi_input is a valid pointer and ffi_output_bytes is a locally
+        // initialized null Bytes.
+        let status = unsafe {
+            signature_generate_witness(std::ptr::from_ref(ffi_input), &raw mut ffi_output_bytes)
+        };
+
+        status.try_into().map(|()| Witness::from(ffi_output_bytes))
+    }
 }
 
 pub fn generate_witness_from_files(dat: &Path, inputs: &Path, output: &Path) -> Result<(), Error> {
@@ -45,11 +51,14 @@ pub fn generate_witness_from_files(dat: &Path, inputs: &Path, output: &Path) ->
     .try_into()
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "embed-circuit"))]
 mod tests {
     use std::{path::PathBuf, sync::LazyLock};
 
-    use super::{SignatureWitnessInput, generate_witness, generate_witness_from_files};
+    use super::{
+        embedded::{SignatureWitnessInput, generate_witness},
+        generate_witness_from_files,
+    };
 
     static LIB_DIR: LazyLock<PathBuf> =
         LazyLock::new(|| PathBuf::from(env!("LBC_ROOT_DIR")).join("signature"));

rust/logos-blockchain-circuits-tests/Cargo.toml

@@ -5,6 +5,10 @@ license.workspace = true
 version.workspace = true
 publish = false
 
+[features]
+default = ["embed-circuits"]
+embed-circuits = ["lbc-pol-sys/embed-circuit", "lbc-poq-sys/embed-circuit"]
+
 [dev-dependencies]
 lbc-pol-sys = { workspace = true }
 lbc-poq-sys = { workspace = true }

rust/logos-blockchain-circuits-tests/tests/conflicts.rs

@@ -1,6 +1,5 @@
-#[cfg(test)]
+#[cfg(all(test, feature = "embed-circuits"))]
 mod tests {
-    use lbc_poq_sys::PoqWitnessInput;
     use logos_blockchain_circuits_tests::inputs;
 
     #[test]
@@ -18,9 +17,9 @@ mod tests {
         let _pol_witness = lbc_pol_sys::generate_witness(&pol_witness_input);
 
         let inputs_json_raw = std::fs::read_to_string(inputs::POQ.as_path()).unwrap();
-        let inputs_json = PoqWitnessInput::new(inputs_json_raw).unwrap();
-        let poq_result = lbc_poq_sys::generate_witness(&inputs_json);
-        assert!(poq_result.is_ok());
+        let poq_witness_input = lbc_poq_sys::PoqWitnessInput::new(inputs_json_raw).unwrap();
+        let poq_witness_result = lbc_poq_sys::generate_witness(&poq_witness_input);
+        assert!(poq_witness_result.is_ok());
     }
 
     #[test]
@@ -31,14 +30,15 @@ mod tests {
             .map(|_| {
                 let json = inputs_json_raw.clone();
                 std::thread::spawn(move || {
-                    let input = PoqWitnessInput::new(json).unwrap();
-                    lbc_poq_sys::generate_witness(&input)
+                    let poq_witness_input = lbc_poq_sys::PoqWitnessInput::new(json)
+                        .expect("PoqWitnessInput::new failed.");
+                    lbc_poq_sys::generate_witness(&poq_witness_input)
                 })
             })
             .collect();
 
-        for h in handles {
-            assert!(h.join().unwrap().is_ok());
+        for handle in handles {
+            assert!(handle.join().unwrap().is_ok());
         }
     }
 }

rust/logos-blockchain-circuits-types/src/lib.rs

@@ -7,4 +7,4 @@
 pub mod ffi;
 pub mod native;
 
-pub use native::{CircuitDat, CircuitWitnessInput, Error};
+pub use native::{Circuit, CircuitWitnessInput, Error};

rust/logos-blockchain-circuits-types/src/native/circuit_witness_input.rs

@@ -2,7 +2,7 @@ use std::{marker::PhantomData, ops::Deref};
 
 use crate::native::{Error, WitnessInput};
 
-pub trait CircuitDat<'dat> {
+pub trait Circuit<'dat> {
     const DAT: &'dat [u8];
 }
 
@@ -11,7 +11,7 @@ pub struct CircuitWitnessInput<'dat, Dat> {
     _phantom: PhantomData<Dat>,
 }
 
-impl<'dat, Dat: CircuitDat<'dat>> CircuitWitnessInput<'dat, Dat> {
+impl<'dat, Dat: Circuit<'dat>> CircuitWitnessInput<'dat, Dat> {
     pub fn new(inputs_json: String) -> Result<Self, Error> {
         let inner = WitnessInput::new(Dat::DAT, inputs_json)?;
         Ok(Self {

rust/logos-blockchain-circuits-types/src/native/mod.rs

@@ -7,7 +7,7 @@ pub mod status;
 pub mod witness;
 pub mod witness_input;
 
-pub use circuit_witness_input::{CircuitDat, CircuitWitnessInput};
+pub use circuit_witness_input::{Circuit, CircuitWitnessInput};
 pub use status::{Error, Result};
 pub use witness::Witness;
 pub use witness_input::WitnessInput;